Belangrijkste inzichten

• Screenshot-actie-loop is het kernpatroon: Je script maakt een screenshot, stuurt deze naar GPT-5.4 via de Responses API met computer_use ingeschakeld, ontvangt gestructureerde actie-commando's (click, type, scroll) en voert deze uit met PyAutoGUI in een loop.
• GPT-5.4 versloeg menselijke experts op OSWorld met 75%: Dit is het eerste AI-model dat menselijke prestaties overtreft op desktop-automatiseringsbenchmarks, waardoor praktische automatisering haalbaar wordt voor echte workflows.
• Kosten zijn verrassend laag: Een typische automatiseringssessie met 10-20 screenshots kost $0.10-0.50, gefactureerd tegen de standaardtarieven van GPT-5.4 (~$10/$30 per miljoen input/output tokens).
• Veiligheid vereist dat jouw code acties uitvoert: GPT-5.4 stuurt alleen actie-commando's — jouw applicatie beslist of deze worden uitgevoerd, wat sandboxed testen en actie-beoordeling essentieel maakt voordat je het zonder toezicht uitvoert.
• Drie vereisten om aan de slag te gaan: Python 3.10+, een OpenAI API-sleutel met Tier 1 access (minimaal $5 eerdere uitgaven), en een desktopomgeving met een display.

GPT-5.4 scoorde 75% op de OSWorld benchmark en versloeg daarmee voor het eerst menselijke experts in desktop-automatisering. Maar het kennen van de benchmarkresultaten en het daadwerkelijk zelf gebruiken van Computer Use zijn twee heel verschillende dingen.

Deze gids overbrugt die kloof. Aan het einde heb je een werkend Python script dat screenshots maakt van je bureaublad, deze naar GPT-5.4 stuurt, gestructureerde actie-commando's ontvangt en deze automatisch uitvoert. Geen theorie, geen hype — alleen code die je vandaag kunt draaien.

---

Wat je gaat bouwen

Je bouwt een complete desktop-automatiseringsloop die als volgt werkt:

1. Je script maakt een screenshot van je scherm.
2. Het stuurt die screenshot naar GPT-5.4 via de OpenAI Responses API met de computer_use tool ingeschakeld.
3. GPT-5.4 analyseert de screenshot en retourneert gestructureerde acties (click, type, scroll, keypress).
4. Je script voert die acties uit met behulp van PyAutoGUI.
5. De loop herhaalt zich totdat de taak is voltooid.

Aan het einde van deze tutorial heb je twee werkende voorbeelden: één die automatisch een webformulier invult, en één die gegevens uit een desktop-applicatie extraheert naar een CSV-bestand.

---

Vereisten

Voordat je begint, zorg ervoor dat je over het volgende beschikt:

• Python 3.10 of later geïnstalleerd op je machine.
• Een OpenAI API-sleutel met toegang tot GPT-5.4 (vereist een betaald account met ten minste Tier 1 access — minimaal $5 eerdere uitgaven).
• Een desktopomgeving — Computer Use werkt op macOS, Windows en Linux met een display. Voor headless servers heb je een virtueel display zoals Xvfb nodig.
• Basiservaring met Python (je hoeft geen expert te zijn — alle code wordt meegeleverd).

---

Stap 1: Je omgeving instellen

Begin met het maken van een projectmap en het installeren van de vereiste pakketten.

mkdir gpt54-computer-use && cd gpt54-computer-use
python -m venv venv
source venv/bin/activate  # On Windows: venv\Scripts\activate

pip install openai pyautogui pillow

Wat elk pakket doet:

• openai — Officiële OpenAI Python SDK voor het aanroepen van de GPT-5.4 API.
• pyautogui — Cross-platform bibliotheek voor het besturen van muis en toetsenbord.
• pillow — Beeldbewerkingsbibliotheek voor het verwerken van screenshots.

Stel vervolgens je API-sleutel in als een omgevingsvariabele:

export OPENAI_API_KEY="sk-your-api-key-here"

Gebruik op Windows in plaats daarvan set OPENAI_API_KEY=sk-your-api-key-here.

Maak een bestand aan met de naam automation.py en voeg de basisopstelling toe:

import os
import base64
import json
import pyautogui
from openai import OpenAI

client = OpenAI()  # Reads OPENAI_API_KEY from environment

# Safety: add a short pause before actions so you can move the mouse
# to a corner to trigger PyAutoGUI's fail-safe and abort
pyautogui.PAUSE = 0.5
pyautogui.FAILSAFE = True

SCREEN_WIDTH, SCREEN_HEIGHT = pyautogui.size()
print(f"Screen resolution: {SCREEN_WIDTH}x{SCREEN_HEIGHT}")

Voer dit uit om te controleren of alles correct is geïnstalleerd:

python automation.py

Je zou je schermresolutie geprint moeten zien. Als je import-fouten krijgt, controleer dan of je de virtuele omgeving hebt geactiveerd en alle pakketten hebt geïnstalleerd.

---

Stap 2: Een screenshot maken

Computer Use werkt door screenshots te analyseren. Je code legt het scherm vast en zet het om naar een base64-gecodeerde string die de API kan accepteren.

Voeg deze functie toe aan automation.py:

def take_screenshot():
    """Capture the screen and return it as a base64-encoded PNG string."""
    screenshot = pyautogui.screenshot()
    # Save to a buffer instead of disk for speed
    import io
    buffer = io.BytesIO()
    screenshot.save(buffer, format="PNG")
    buffer.seek(0)
    return base64.b64encode(buffer.read()).decode("utf-8")

Test het door een snelle controle onderaan het bestand toe te voegen:

if __name__ == "__main__":
    img_data = take_screenshot()
    print(f"Screenshot captured: {len(img_data)} characters (base64)")

Dit zou iets moeten printen als Screenshot captured: 2847392 characters (base64). Het exacte aantal hangt af van je schermresolutie en wat er op het scherm staat.

---

Stap 3: Een screenshot naar GPT-5.4 sturen

Nu komt de kern van Computer Use: een screenshot naar GPT-5.4 sturen met de computer_use tool ingeschakeld, en gestructureerde actie-commando's terugkrijgen.

Voeg deze functie toe:

def send_to_gpt54(screenshot_b64, task_description, previous_response_id=None):
    """
    Send a screenshot to GPT-5.4 with computer_use enabled.
    Returns the API response with action commands.
    """
    tools = [
        {
            "type": "computer_use_preview",
            "display_width": SCREEN_WIDTH,
            "display_height": SCREEN_HEIGHT,
            "environment": "mac"  # Change to "windows" or "linux" as needed
        }
    ]

    input_content = [
        {
            "role": "user",
            "content": [
                {
                    "type": "text",
                    "text": task_description
                },
                {
                    "type": "image_url",
                    "image_url": {
                        "url": f"data:image/png;base64,{screenshot_b64}"
                    }
                }
            ]
        }
    ]

    params = {
        "model": "gpt-5.4",
        "tools": tools,
        "input": input_content,
        "reasoning": {"effort": "medium"}
    }

    if previous_response_id:
        params["previous_response_id"] = previous_response_id

    response = client.responses.create(**params)
    return response

Belangrijke parameters uitgelegd:

• computer_use_preview — Vertelt GPT-5.4 om de screenshot te analyseren en desktop-acties te retourneren.
• display_width / display_height — Je schermresolutie, zodat GPT-5.4 coördinaten retourneert die overeenkomen met je werkelijke weergave.
• environment — Ingesteld op "mac", "windows", of "linux" zodat GPT-5.4 de juiste sneltoetsen en UI-conventies gebruikt.
• reasoning.effort — Bepaalt hoeveel reasoning GPT-5.4 doet. Gebruik "medium" voor standaardtaken, "high" voor complexe workflows met meerdere stappen.
• previous_response_id — Koppelt meerdere aanroepen aan elkaar zodat GPT-5.4 onthoudt wat het al heeft gedaan.

---

Stap 4: Acties uitvoeren

GPT-5.4 retourneert gestructureerde actie-commando's in zijn antwoord. Je moet deze parsen en uitvoeren met PyAutoGUI.

Voeg de actie-executor toe:

def execute_action(action):
    """Execute a single computer_use action using PyAutoGUI."""
    action_type = action.type

    if action_type == "click":
        x, y = action.x, action.y
        button = getattr(action, "button", "left")
        print(f"  -> Click ({button}) at ({x}, {y})")
        pyautogui.click(x, y, button=button)

    elif action_type == "double_click":
        x, y = action.x, action.y
        print(f"  -> Double-click at ({x}, {y})")
        pyautogui.doubleClick(x, y)

    elif action_type == "type":
        text = action.text
        print(f"  -> Type: {text[:50]}{'...' if len(text) > 50 else ''}")
        pyautogui.write(text, interval=0.03)

    elif action_type == "keypress":
        keys = action.keys
        print(f"  -> Keypress: {keys}")
        for key in keys:
            pyautogui.press(key)

    elif action_type == "scroll":
        x, y = action.x, action.y
        scroll_x = getattr(action, "scroll_x", 0)
        scroll_y = getattr(action, "scroll_y", 0)
        print(f"  -> Scroll at ({x}, {y}): x={scroll_x}, y={scroll_y}")
        pyautogui.scroll(scroll_y, x=x, y=y)

    elif action_type == "drag":
        start_x, start_y = action.start_x, action.start_y
        end_x, end_y = action.end_x, action.end_y
        print(f"  -> Drag from ({start_x}, {start_y}) to ({end_x}, {end_y})")
        pyautogui.moveTo(start_x, start_y)
        pyautogui.drag(end_x - start_x, end_y - start_y, duration=0.5)

    elif action_type == "screenshot":
        print("  -> Model requested a new screenshot")
        return "screenshot_requested"

    else:
        print(f"  -> Unknown action type: {action_type}")

    return "executed"


def process_response(response):
    """Parse GPT-5.4's response and execute all actions."""
    needs_screenshot = False

    for item in response.output:
        if item.type == "computer_call":
            action = item.action
            result = execute_action(action)
            if result == "screenshot_requested":
                needs_screenshot = True
        elif item.type == "text":
            print(f"  GPT-5.4 says: {item.text}")

    return needs_screenshot, response.id

Dit handelt alle actietypes af die GPT-5.4 kan retourneren: klikken, dubbelklikken, typen, toetsaanslagen, scrollen en slepen.

---

Stap 5: De automatiseringsloop bouwen

Koppel nu alles aan elkaar tot een volledige automatiseringsloop. Dit is de hoofdmotor die je taken uitvoert:

import time

def run_automation(task_description, max_steps=25):
    """
    Run a complete automation loop:
    screenshot -> send to GPT-5.4 -> execute actions -> repeat.
    """
    print(f"Starting automation: {task_description}")
    print(f"Max steps: {max_steps}")
    print("-" * 60)

    previous_response_id = None

    for step in range(1, max_steps + 1):
        print(f"\nStep {step}/{max_steps}")

        # 1. Take a screenshot
        print("  Capturing screenshot...")
        screenshot_b64 = take_screenshot()

        # 2. Send to GPT-5.4
        print("  Sending to GPT-5.4...")
        response = send_to_gpt54(
            screenshot_b64,
            task_description if step == 1 else "Continue the task based on the current screen state.",
            previous_response_id
        )

        # 3. Check if the model thinks we're done
        has_actions = False
        for item in response.output:
            if item.type == "computer_call":
                has_actions = True
                break

        if not has_actions:
            # Check if model sent a text response (likely done or needs input)
            for item in response.output:
                if item.type == "text":
                    print(f"\n  GPT-5.4: {item.text}")
            print("\n" + "=" * 60)
            print("Automation complete (no more actions to perform).")
            return True

        # 4. Execute the actions
        print("  Executing actions...")
        needs_screenshot, previous_response_id = process_response(response)

        # 5. Brief pause to let UI update
        time.sleep(1.0)

    print("\n" + "=" * 60)
    print(f"Reached maximum steps ({max_steps}). Stopping.")
    return False

Je kunt nu elke automatiseringstaak uitvoeren met een enkele functie-aanroep:

if __name__ == "__main__":
    run_automation("Open the Calculator app and compute 1234 * 5678")

Dit legt je scherm vast, stuurt het naar GPT-5.4, en GPT-5.4 zal uitvinden hoe de Calculator geopend moet worden en de vermenigvuldiging moet worden uitgevoerd — door op knoppen te klikken, het resultaat te lezen en te stoppen wanneer het klaar is.

---

Praktijkvoorbeeld 1: Automatisch een webformulier invullen

Hier is een volledig werkend voorbeeld dat een web-contactformulier invult. Sla dit op als autofill_form.py:

import os
import base64
import io
import time
import pyautogui
from openai import OpenAI

client = OpenAI()
pyautogui.PAUSE = 0.5
pyautogui.FAILSAFE = True
SCREEN_WIDTH, SCREEN_HEIGHT = pyautogui.size()


def take_screenshot():
    screenshot = pyautogui.screenshot()
    buffer = io.BytesIO()
    screenshot.save(buffer, format="PNG")
    buffer.seek(0)
    return base64.b64encode(buffer.read()).decode("utf-8")


def autofill_contact_form():
    """
    Auto-fill a contact form with sample data.
    Open the web page with the form before running this script.
    """
    form_data = {
        "First Name": "Jane",
        "Last Name": "Doe",
        "Email": "jane.doe@example.com",
        "Phone": "555-0123",
        "Company": "Acme Corp",
        "Message": "I am interested in learning more about your enterprise plan."
    }

    task = f"""Fill out the contact form visible on the screen with this data:
{chr(10).join(f'- {k}: {v}' for k, v in form_data.items())}

Click each field, clear any existing text, type the value, then move to the next field.
After filling all fields, click the Submit button.
Do NOT press Enter to submit — click the Submit button instead."""

    print("Starting form auto-fill...")
    print(f"Data to fill: {json.dumps(form_data, indent=2)}")

    previous_response_id = None

    for step in range(1, 20):
        print(f"\nStep {step}")
        screenshot_b64 = take_screenshot()

        tools = [{
            "type": "computer_use_preview",
            "display_width": SCREEN_WIDTH,
            "display_height": SCREEN_HEIGHT,
            "environment": "mac"
        }]

        input_content = [{
            "role": "user",
            "content": [
                {"type": "text", "text": task if step == 1 else "Continue filling the form."},
                {"type": "image_url", "image_url": {"url": f"data:image/png;base64,{screenshot_b64}"}}
            ]
        }]

        params = {
            "model": "gpt-5.4",
            "tools": tools,
            "input": input_content,
            "reasoning": {"effort": "medium"}
        }
        if previous_response_id:
            params["previous_response_id"] = previous_response_id

        response = client.responses.create(**params)

        has_actions = False
        for item in response.output:
            if item.type == "computer_call":
                has_actions = True
                action = item.action
                if action.type == "click":
                    pyautogui.click(action.x, action.y)
                elif action.type == "type":
                    pyautogui.write(action.text, interval=0.03)
                elif action.type == "keypress":
                    for key in action.keys:
                        pyautogui.press(key)
                elif action.type == "scroll":
                    pyautogui.scroll(action.scroll_y, x=action.x, y=action.y)

        if not has_actions:
            for item in response.output:
                if item.type == "text":
                    print(f"GPT-5.4: {item.text}")
            print("Form filling complete.")
            return

        previous_response_id = response.id
        time.sleep(0.8)


if __name__ == "__main__":
    import json
    print("Make sure the web form is visible on your screen.")
    print("Starting in 3 seconds...")
    time.sleep(3)
    autofill_contact_form()

Hoe het te gebruiken:

1. Open een webpagina met een contactformulier in je browser.
2. Zorg ervoor dat het formulier volledig zichtbaar is op het scherm (geen scrollen nodig voor de eerste velden).
3. Voer python autofill_form.py uit.
4. Kijk hoe GPT-5.4 elk veld identificeert, erop klikt en de juiste waarde typt.

---

Praktijkvoorbeeld 2: Gegevens extraheren uit een desktop-app

Dit voorbeeld leest gegevens uit een zichtbare spreadsheet- of tabel-applicatie en slaat deze op in een CSV-bestand. Sla dit op als extract_data.py:

import os
import base64
import io
import csv
import time
import pyautogui
from openai import OpenAI

client = OpenAI()
pyautogui.PAUSE = 0.3
pyautogui.FAILSAFE = True
SCREEN_WIDTH, SCREEN_HEIGHT = pyautogui.size()


def take_screenshot():
    screenshot = pyautogui.screenshot()
    buffer = io.BytesIO()
    screenshot.save(buffer, format="PNG")
    buffer.seek(0)
    return base64.b64encode(buffer.read()).decode("utf-8")


def extract_table_data(output_file="extracted_data.csv"):
    """
    Look at the current screen, identify any table or spreadsheet,
    and extract its contents to a CSV file.
    """
    screenshot_b64 = take_screenshot()

    response = client.responses.create(
        model="gpt-5.4",
        input=[{
            "role": "user",
            "content": [
                {
                    "type": "text",
                    "text": """Look at this screenshot carefully. There is a table or spreadsheet visible.
Extract ALL the data from the visible table into a structured JSON format.
Return ONLY a JSON object with this structure:
{
  "headers": ["Column1", "Column2", ...],
  "rows": [["value1", "value2", ...], ...]
}
Include every visible row. Do not summarize or skip any data."""
                },
                {
                    "type": "image_url",
                    "image_url": {"url": f"data:image/png;base64,{screenshot_b64}"}
                }
            ]
        }],
        reasoning={"effort": "high"}
    )

    # Parse the JSON response
    response_text = response.output_text
    # Clean up markdown code fences if present
    if "```json" in response_text:
        response_text = response_text.split("```json")[1].split("```")[0]
    elif "```" in response_text:
        response_text = response_text.split("```")[1].split("```")[0]

    import json
    data = json.loads(response_text.strip())

    # Write to CSV
    with open(output_file, "w", newline="") as f:
        writer = csv.writer(f)
        writer.writerow(data["headers"])
        writer.writerows(data["rows"])

    row_count = len(data["rows"])
    col_count = len(data["headers"])
    print(f"Extracted {row_count} rows x {col_count} columns to {output_file}")
    return output_file


def extract_multi_page_data(output_file="full_data.csv", max_pages=10):
    """
    Extract data from a table that spans multiple pages.
    Scrolls down and extracts each page, then combines results.
    """
    all_rows = []
    headers = None

    for page in range(max_pages):
        print(f"Extracting page {page + 1}...")
        screenshot_b64 = take_screenshot()

        prompt = "Extract ALL table data visible on screen as JSON: {\"headers\": [...], \"rows\": [[...], ...]}"
        if page > 0:
            prompt += " Do NOT include the header row if it is repeated from the previous page."

        response = client.responses.create(
            model="gpt-5.4",
            input=[{
                "role": "user",
                "content": [
                    {"type": "text", "text": prompt},
                    {"type": "image_url", "image_url": {"url": f"data:image/png;base64,{screenshot_b64}"}}
                ]
            }],
            reasoning={"effort": "high"}
        )

        response_text = response.output_text
        if "```json" in response_text:
            response_text = response_text.split("```json")[1].split("```")[0]
        elif "```" in response_text:
            response_text = response_text.split("```")[1].split("```")[0]

        import json
        data = json.loads(response_text.strip())

        if headers is None:
            headers = data["headers"]

        if not data["rows"]:
            print("No more data found. Stopping.")
            break

        all_rows.extend(data["rows"])
        print(f"  Found {len(data['rows'])} rows (total: {len(all_rows)})")

        # Scroll down for next page
        pyautogui.scroll(-5)
        time.sleep(1.0)

    # Write combined CSV
    with open(output_file, "w", newline="") as f:
        writer = csv.writer(f)
        writer.writerow(headers)
        writer.writerows(all_rows)

    print(f"\nDone. Extracted {len(all_rows)} total rows to {output_file}")
    return output_file


if __name__ == "__main__":
    print("Make sure a spreadsheet or table is visible on your screen.")
    print("Starting extraction in 3 seconds...")
    time.sleep(3)
    extract_table_data()

Hoe het te gebruiken:

1. Open een spreadsheet, database-viewer of een andere app met tabelgegevens zichtbaar op het scherm.
2. Voer python extract_data.py uit.
3. Controleer het gegenereerde extracted_data.csv voor de geëxtraheerde inhoud.

Voor tabellen die over meerdere pagina's verspreid zijn, roep je in plaats daarvan extract_multi_page_data() aan. Dit zal automatisch scrollen en alle pagina's combineren in één CSV.

---

Best practices voor veiligheid

Computer Use geeft GPT-5.4 de mogelijkheid om je muis en toetsenbord te besturen. Die kracht vereist voorzichtigheid.

Altijd eerst sandboxed. Voordat je automatisering uitvoert op je echte bureaublad, test je in een virtuele machine of een Docker-container met een virtueel display. Dit isoleert fouten en voorkomt onbedoelde schade.

Beoordeel acties voor uitvoering. Pas de execute_action functie aan om elke actie te printen en op jouw bevestiging te wachten voordat deze wordt uitgevoerd:

def execute_action_safe(action):
    """Execute action only after user confirmation."""
    print(f"  Proposed action: {action.type}", end="")
    if hasattr(action, "x"):
        print(f" at ({action.x}, {action.y})", end="")
    if hasattr(action, "text"):
        print(f" text='{action.text[:30]}'", end="")
    print()

    confirm = input("  Execute? (y/n): ").strip().lower()
    if confirm == "y":
        execute_action(action)
    else:
        print("  Skipped.")

Stel limieten in. Voeg een maximaal aantal acties per sessie en een maximaal kostenbudget toe. De max_steps parameter in run_automation beperkt al het aantal loops. Je kunt ook het tokengebruik bijhouden via het response-object om de kosten te monitoren.

Automatiseer nooit gevoelige accounts zonder toezicht. Richt Computer Use niet op je bank-app, e-mail met gevoelige gegevens of admin-consoles zonder elke actie in de gaten te houden. GPT-5.4 kan verkeerd klikken, UI-elementen verkeerd lezen of onbedoelde paden bewandelen.

Gebruik PyAutoGUI's fail-safe. Met pyautogui.FAILSAFE = True (wat de standaardinstelling is), kun je elke automatisering afbreken door je muis snel naar de linkerbovenhoek van het scherm te bewegen. Houd dit te allen tijde ingeschakeld.

---

Veelvoorkomende problemen oplossen

"Model retourneert geen acties" -- Zorg ervoor dat je computer_use_preview gebruikt als tooltype, niet alleen computer_use. Controleer ook of je display_width en display_height overeenkomen met je werkelijke schermresolutie. Als de waarden onjuist zijn, kan GPT-5.4 de screenshot mogelijk niet correct interpreteren.

"Klikken landen op de verkeerde positie" -- Dit gebeurt meestal op schermen met schaling (bijv. Retina-displays op macOS). PyAutoGUI werkt in pixelcoördinaten, maar je scherm kan logische coördinaten gebruiken. Probeer je resolutie vast te leggen met pyautogui.size() en vergelijk deze met je werkelijke pixelresolutie. Op macOS met Retina moet je coördinaten mogelijk delen door je schalingsfactor.

"PyAutoGUI kan het scherm niet vinden" -- Installeer en start op headless Linux servers Xvfb: Xvfb :99 -screen 0 1920x1080x24 & en vervolgens export DISPLAY=:99. Op macOS moet je Terminal (of je IDE) toegankelijkheidsrechten geven in Systeeminstellingen > Privacy en beveiliging > Toegankelijkheid.

"API retourneert een 429 rate limit fout" -- Voeg een time.sleep(2) toe tussen API-aanroepen, of implementeer exponential backoff. GPT-5.4 Computer Use-sessies kunnen rate limits raken als je screenshots te snel verstuurt.

"Hoge tokenkosten" -- Screenshots op volledige resolutie verbruiken veel tokens. Verlaag de kosten door screenshots te verkleinen voordat je ze codeert:

def take_screenshot_resized(max_width=1280):
    screenshot = pyautogui.screenshot()
    ratio = max_width / screenshot.width
    new_size = (max_width, int(screenshot.height * ratio))
    screenshot = screenshot.resize(new_size)
    buffer = io.BytesIO()
    screenshot.save(buffer, format="PNG")
    buffer.seek(0)
    return base64.b64encode(buffer.read()).decode("utf-8"), ratio

Vergeet niet om bij het gebruik van verkleinde screenshots de door GPT-5.4 geretourneerde coördinaten te vermenigvuldigen met de inverse van de ratio voordat je ze doorgeeft aan PyAutoGUI.

"GPT-5.4 komt vast te zitten in een loop" -- Als het model dezelfde actie blijft herhalen, kan het in de war zijn door de UI-status. Voeg logica toe om herhaalde acties te detecteren en de loop te onderbreken, of verhoog de reasoning-inspanning naar "high" voor een betere besluitvorming.

---

Wat nu?

Zodra je de basis automatiseringsloop werkend hebt, zijn hier manieren om deze uit te breiden:

Koppel meerdere taken. Bouw een workflow die je e-mail opent, een bijlage downloadt, deze opent in een spreadsheet, specifieke cellen extraheert en de waarden in een rapportsjabloon plakt. Elke stap gebruikt dezelfde screenshot-analyseer-handel-loop.

Voeg foutherstel toe. Controleer elke screenshot op foutmeldingen of onverwachte statussen. Als GPT-5.4 detecteert dat er iets mis is gegaan, kan het proberen te herstellen door op "Annuleren" te klikken, op Escape te drukken of de laatste actie opnieuw te proberen.

Combineer met Playwright voor browsertaken. Voor automatisering die alleen op het web plaatsvindt, kan GPT-5.4 ook Playwright-code schrijven om programmatisch met browsers te communiceren. Dit is sneller en betrouwbaarder dan op screenshots gebaseerd klikken voor gestructureerde webpagina's. Gebruik Computer Use voor desktop-apps en Playwright voor browserautomatisering.

Bouw een takencollectie. Sla veelvoorkomende prompts en workflows op als herbruikbare functies. Maak een tasks/ map met scripts zoals fill_invoice.py, export_report.py, en update_crm.py die je team op aanvraag kan uitvoeren.

Plan automatiseringen. Gebruik cron (Linux/macOS) of Task Scheduler (Windows) om je automatiseringsscripts op gezette tijden uit te voeren. Combineer met een virtueel display voor volledig headless gebruik.

GPT-5.4 Computer Use is nog een nieuwe mogelijkheid en de API-interface zal zich verder ontwikkelen. Houd je openai pakket up-to-date met pip install --upgrade openai om de nieuwste tooltypes en parameters te krijgen terwijl OpenAI de functie verfijnt.

De code in deze tutorial geeft je een werkende basis. Begin met eenvoudige taken met een laag risico, valideer of de automatisering correct werkt, en schaal dan op naar complexere workflows naarmate je meer vertrouwen krijgt in het systeem.