Blog

Como Usar a API do GPT-5.4

Ashley Innocent

Ashley Innocent

6 março 2026

Como Usar a API do GPT-5.4

Em Resumo / Resposta Rápida

Para usar a API do GPT-5.4: Instale o SDK da OpenAI (pip install openai), inicialize o cliente com a chave da API, chame chat.completions.create() com o modelo gpt-5.4. Principais recursos: uso do computador (automação nativa do navegador), busca de ferramentas (redução de 47% de tokens), janela de contexto de 1M, capacidades de visão. Preço: $2.50/M tokens de entrada, $15/M tokens de saída. Este guia cobre a configuração, exemplos de código, configuração de uso do computador, integração de ferramentas e melhores práticas de produção.

Introdução

O GPT-5.4 não é apenas mais uma atualização de modelo. É o primeiro modelo de propósito geral da OpenAI com capacidades nativas de uso de computador, busca eficiente de ferramentas e janelas de contexto de 1M de tokens. Usar o GPT-5.4 de forma eficaz requer a compreensão dessas novas capacidades e como integrá-las aos seus fluxos de trabalho.

Este guia fornece exemplos de código funcionais para cada um dos principais recursos do GPT-5.4. Você aprenderá como implementar a automação do uso do computador, configurar a busca de ferramentas para servidores MCP, processar imagens de alta resolução, lidar com bases de código de contexto longo e otimizar custos para implantações em produção.

Seja você construindo agentes de IA, automatizando fluxos de trabalho de navegador ou integrando o GPT-5.4 em aplicações existentes, este guia oferece os detalhes de implementação de que você precisa.

💡
Ao integrar o GPT-5.4 em aplicações, use o Apidog para projetar, testar e documentar seus endpoints de API. A plataforma unificada do Apidog ajuda a depurar requisições de API, criar suítes de teste automatizadas, simular respostas durante o desenvolvimento e gerar documentação para sua equipe. Isso é especialmente valioso ao construir recursos alimentados por IA que combinam o GPT-5.4 com outros serviços.
botão

Início Rápido: Sua Primeira Requisição GPT-5.4

Comece a usar o GPT-5.4 em menos de 5 minutos. Antes de escrever código, teste suas requisições da API GPT-5.4 no Apidog:

  1. Crie uma nova requisição HTTP com POST para https://api.openai.com/v1/chat/completions
  2. Adicione o cabeçalho de Autorização: Bearer SUA_CHAVE_API
  3. Defina o corpo da requisição com o modelo, mensagens e parâmetros
  4. Envie e inspecione a resposta
  5. Salve em uma coleção para testes repetidos
  6. Use variáveis de ambiente para alternar entre as chaves de API
Interface do Apidog para criar uma requisição POST de API OpenAI GPT-5.4
Essa abordagem visual acelera os testes iniciais e ajuda você a entender a estrutura da API antes de implementar no código.

Pré-requisitos

Início Rápido com Python

from openai import OpenAI
import os

# Initialize client
client = OpenAI(
    api_key=os.getenv("OPENAI_API_KEY")
)

# Make request
response = client.chat.completions.create(
    model="gpt-5.4",
    messages=[
        {"role": "system", "content": "You are a helpful coding assistant."},
        {"role": "user", "content": "Write a Python function to sort a list of dictionaries by a key."}
    ]
)

print(response.choices[0].message.content)

Início Rápido com Node.js

const OpenAI = require('openai');

const client = new OpenAI({
    apiKey: process.env.OPENAI_API_KEY
});

async function main() {
    const response = await client.chat.completions.create({
        model: 'gpt-5.4',
        messages: [
            { role: 'system', content: 'You are a helpful coding assistant.' },
            { role: 'user', content: 'Write a Python function to sort a list of dictionaries by a key.' }
        ]
    });

    console.log(response.choices[0].message.content);
}

main();

Saída Esperada

def sort_dicts_by_key(dict_list, key, reverse=False):
    """
    Sort a list of dictionaries by a specified key.

    Args:
        dict_list: List of dictionaries to sort
        key: The dictionary key to sort by
        reverse: If True, sort in descending order

    Returns:
        Sorted list of dictionaries
    """
    return sorted(dict_list, key=lambda x: x.get(key, ''), reverse=reverse)

# Example usage
data = [
    {'name': 'Alice', 'age': 30},
    {'name': 'Bob', 'age': 25},
    {'name': 'Charlie', 'age': 35}
]

sorted_by_age = sort_dicts_by_key(data, 'age')
print(sorted_by_age)
# [{'name': 'Bob', 'age': 25}, {'name': 'Alice', 'age': 30}, {'name': 'Charlie', 'age': 35}]

Compreendendo as Capacidades do GPT-5.4

O GPT-5.4 se destaca em quatro áreas principais. Compreendê-las ajuda você a escolher a abordagem certa para cada caso de uso.

1. Trabalho de Conhecimento (Taxa de Vitória GDPval de 83%)

Melhor para:

Gráfico mostrando a taxa de vitória do GPT-5.4 em tarefas de trabalho de conhecimento, como criação de planilhas, geração de apresentações e modelagem financeira.

2. Uso do Computador (75% Verificado pela OSWorld)

Melhor para:

Diagrama mostrando o fluxo de trabalho de automação de computador do GPT-5.4: captura de tela > GPT-5.4 > Comandos de computador > Executar comandos.

3. Codificação (57.7% SWE-Bench Pro)

Melhor para:

Gráfico mostrando a pontuação do GPT-5.4 no benchmark SWE-Bench Pro para tarefas de codificação, incluindo desenvolvimento full-stack e depuração.

4. Integração de Ferramentas (54.6% Toolathlon)

Melhor para:

Gráfico mostrando o desempenho do GPT-5.4 no benchmark Toolathlon para integração de ferramentas e fluxos de trabalho de API multi-etapas.

API de Uso do Computador

As capacidades nativas de uso do computador do GPT-5.4 representam o maior avanço nesta versão. O modelo pode operar computadores através de capturas de tela, comandos de mouse e entrada de teclado.

Diagrama ilustrando o fluxo de trabalho da API de uso do computador do GPT-5.4, mostrando capturas de tela, comandos do modelo e execução de ações.
Ao construir aplicações com capacidades de uso do computador, teste cada etapa do fluxo de trabalho no Apidog:

Como o Uso do Computador Funciona

O fluxo de trabalho de uso do computador utiliza a ferramenta computer nas requisições da API. O modelo:

  1. Recebe capturas de tela do estado atual da tela
  2. Analisa elementos da interface do usuário e determina ações
  3. Retorna comandos do computador (clicar, digitar, rolar, etc.)
  4. Sua aplicação executa os comandos e captura novas capturas de tela
  5. O loop continua até a conclusão da tarefa

Configuração Básica de Uso do Computador

from openai import OpenAI
import base64

client = OpenAI()

def take_screenshot():
    """Capture current screen state - implement for your platform."""
    # Use pyautogui, PIL, or platform-specific screenshot
    import pyautogui
    screenshot = pyautogui.screenshot()
    import io
    buffer = io.BytesIO()
    screenshot.save(buffer, format='PNG')
    return base64.b64encode(buffer.getvalue()).decode('utf-8')

def execute_computer_command(command):
    """Execute computer command - implement based on command type."""
    import pyautogui

    action = command.get('action')

    if action == 'click':
        x, y = command.get('coordinate', [0, 0])
        pyautogui.click(x, y)
    elif action == 'type':
        text = command.get('text', '')
        pyautogui.write(text, interval=0.05)
    elif action == 'scroll':
        amount = command.get('scroll_amount', 0)
        pyautogui.scroll(amount)
    elif action == 'keypress':
        key = command.get('key', '')
        pyautogui.press(key)

    # Return new screenshot after action
    return take_screenshot()

# Computer use conversation
messages = [{
    "role": "user",
    "content": [
        {
            "type": "text",
            "text": "Navigate to gmail.com and log in with the credentials I provided."
        },
        {
            "type": "image_url",
            "image_url": {
                "url": f"data:image/png;base64,{take_screenshot()}"
            }
        }
    ]
}]

# Request with computer tool
response = client.chat.completions.create(
    model="gpt-5.4",
    messages=messages,
    tools=[{
        "type": "computer",
        "display_width": 1920,
        "display_height": 1080,
        "display_number": 1
    }],
    tool_choice="required"
)

# Parse and execute computer commands
for tool_call in response.choices[0].message.tool_calls:
    if tool_call.type == "computer":
        command = tool_call.function.arguments
        new_screenshot = execute_computer_command(command)

        # Continue conversation with new screenshot
        messages.append({
            "role": "assistant",
            "content": response.choices[0].message.content
        })
        messages.append({
            "role": "user",
            "content": [{
                "type": "image_url",
                "image_url": {"url": f"data:image/png;base64,{new_screenshot}"}
            }]
        })

Políticas de Segurança de Uso do Computador

Configure o comportamento de segurança com base na sua tolerância a riscos:

# Safe mode - requires confirmation for sensitive actions
response = client.chat.completions.create(
    model="gpt-5.4",
    messages=messages,
    tools=[{
        "type": "computer",
        "display_width": 1920,
        "display_height": 1080,
        "confirmation_policy": "always"  # or "never" or "selective"
    }],
    # Custom system message for safety
    system_message="""You are operating a computer. Follow these safety rules:
    1. Never enter credentials without explicit user confirmation
    2. Ask before deleting files or data
    3. Confirm before sending emails or messages
    4. Report any errors or unexpected states immediately
    """
)

Exemplo de Automação de Navegador

Automatize tarefas de navegador com integração Playwright:

from playwright.sync_api import sync_playwright

def browser_automation_workflow():
    with sync_playwright() as p:
        browser = p.chromium.launch(headless=False)
        page = browser.new_page()

        # Navigate to page
        page.goto("https://example.com")

        # Get screenshot for GPT-5.4
        screenshot = page.screenshot()
        screenshot_b64 = base64.b64encode(screenshot).decode('utf-8')

        messages = [{
            "role": "user",
            "content": [
                {"type": "text", "text": "Find the login form and fill it out."},
                {"type": "image_url", "image_url": {"url": f"data:image/png;base64,{screenshot_b64}"}}
            ]
        }]

        # Get computer commands from GPT-5.4
        response = client.chat.completions.create(
            model="gpt-5.4",
            messages=messages,
            tools=[{"type": "computer"}],
            tool_choice="required"
        )

        # Parse and execute commands on browser
        for tool_call in response.choices[0].message.tool_calls:
            if tool_call.type == "computer":
                command = json.loads(tool_call.function.arguments)

                if command.get('action') == 'click':
                    x, y = command.get('coordinate', [0, 0])
                    page.mouse.click(x, y)
                elif command.get('action') == 'type':
                    page.keyboard.type(command.get('text', ''))

                # Get new screenshot and continue
                new_screenshot = page.screenshot()
                # ... continue loop

Automação de E-mail e Calendário

Exemplo do mundo real: Processar e-mails e agendar eventos:

def process_email_and_schedule_meeting():
    """
    Workflow: Read unread emails, extract meeting requests,
    check calendar availability, and send calendar invites.
    """

    workflow_prompt = """
    Complete this workflow:
    1. Open Gmail and find unread emails from the last 24 hours
    2. Identify any meeting requests or scheduling questions
    3. For each meeting request:
       - Extract proposed dates/times
       - Note attendees and meeting purpose
    4. Open Google Calendar and check availability
    5. Send calendar invites for confirmed meetings
    6. Reply to emails confirming the scheduled time

    Report back with a summary of what was accomplished.
    """

    # Start with inbox screenshot
    screenshot = take_screenshot()

    messages = [{
        "role": "user",
        "content": [
            {"type": "text", "text": workflow_prompt},
            {"type": "image_url", "image_url": {"url": f"data:image/png;base64,{screenshot}"}}
        ]
    }]

    # Execute multi-turn computer use workflow
    for turn in range(10):  # Limit turns to prevent infinite loops
        response = client.chat.completions.create(
            model="gpt-5.4",
            messages=messages,
            tools=[{"type": "computer"}],
            tool_choice="required"
        )

        # Check if task is complete
        if "complete" in response.choices[0].message.content.lower():
            print(f"Workflow completed in {turn + 1} turns")
            break

        # Execute computer commands and get new screenshot
        # ... (command execution logic from earlier example)

Otimização de Desempenho

Resultados da Mainstay processando 30 mil portais de impostos sobre a propriedade:

Dicas para otimização:

  1. Use capturas de tela de alta qualidade (mínimo 1920x1080)
  2. Forneça descrições de tarefas claras e específicas
  3. Implemente limites de turnos para evitar loops
  4. Armazene em cache as capturas de tela para evitar capturas redundantes
  5. Use políticas de confirmação seletiva para fluxos de trabalho confiáveis

Busca e Integração de Ferramentas

A busca de ferramentas reduz o uso de tokens em 47%, ao mesmo tempo em que permite trabalhar com grandes ecossistemas de ferramentas.

Como a Busca de Ferramentas Funciona

Em vez de carregar todas as definições de ferramentas antecipadamente, o modelo recebe uma lista leve e pesquisa as definições sob demanda.

Diagrama ilustrando o processo de busca de ferramentas, onde o GPT-5.4 recebe uma lista leve de ferramentas e solicita definições completas conforme necessário.

Configuração Básica de Busca de Ferramentas

# Define available tools (lightweight list)
available_tools = [
    {
        "name": "get_weather",
        "description": "Get current weather for a location"
    },
    {
        "name": "send_email",
        "description": "Send an email to a recipient"
    },
    {
        "name": "calendar_search",
        "description": "Search calendar for events"
    },
    # ... hundreds more tools
]

# Initial request - model sees tool list, not full definitions
response = client.chat.completions.create(
    model="gpt-5.4",
    messages=[
        {"role": "user", "content": "What's the weather in Tokyo and send it to my team?"}
    ],
    tools=available_tools,
    tool_choice="auto"
)

# If model wants to use a tool, it requests the definition
# Your application provides the full definition at that point

Integração de Servidores MCP

O benchmark MCP Atlas da Scale mostrou uma redução de 47% de tokens com a busca de ferramentas.

# MCP Server with many tools
mcp_servers = [
    {
        "name": "filesystem",
        "description": "File system operations",
        "tool_count": 12
    },
    {
        "name": "database",
        "description": "Database query operations",
        "tool_count": 8
    },
    {
        "name": "web-search",
        "description": "Web search and scraping",
        "tool_count": 15
    }
    # ... 36 MCP servers in benchmark
]

# Tool search configuration
response = client.chat.completions.create(
    model="gpt-5.4",
    messages=[
        {"role": "user", "content": "Find all Python files modified today and search for TODO comments."}
    ],
    tools=mcp_servers,
    # Tool search enabled automatically when using this pattern
    parallel_tool_calls=True
)

# Model will request tool definitions as needed
# Token savings: 47% vs loading all definitions upfront

Fluxos de Trabalho Multi-Etapas no Estilo Toolathlon

O Toolathlon testa fluxos de trabalho complexos de ferramentas em várias etapas:

def grade_assignments_workflow():
    """
    Complex workflow: Read emails with attachments,
    upload to grading system, grade assignments,
    record results in spreadsheet.
    """

    workflow_steps = """
    1. Read emails from students with assignment attachments
    2. Download each attachment
    3. Upload to grading portal
    4. Grade each assignment using rubric
    5. Record grades in spreadsheet
    6. Send confirmation emails to students
    """

    tools = [
        {"name": "email_read", "description": "Read emails from inbox"},
        {"name": "email_send", "description": "Send emails"},
        {"name": "file_download", "description": "Download file attachments"},
        {"name": "file_upload", "description": "Upload files to web portal"},
        {"name": "web_form_fill", "description": "Fill and submit web forms"},
        {"name": "spreadsheet_write", "description": "Write data to spreadsheet"},
        {"name": "rubric_evaluate", "description": "Evaluate work against rubric"}
    ]

    response = client.chat.completions.create(
        model="gpt-5.4",
        messages=[
            {"role": "user", "content": workflow_steps}
        ],
        tools=tools,
        parallel_tool_calls=True  # Enable parallel tool execution
    )

    # GPT-5.4 achieves 54.6% on Toolathlon vs 45.7% for GPT-5.2
    # Key: Better tool selection and fewer turns required

Visão e Processamento de Imagens

O GPT-5.4 suporta percepção visual aprimorada com detalhes de imagem originais de até 10.24M pixels.

Níveis de Detalhe da Imagem

# Original detail - highest fidelity (10.24M pixels, 6000px max dimension)
response = client.chat.completions.create(
    model="gpt-5.4",
    messages=[{
        "role": "user",
        "content": [
            {
                "type": "image_url",
                "image_url": {
                    "url": "https://example.com/high-res-image.jpg",
                    "detail": "original"  # or "high" or "low"
                }
            },
            {"type": "text", "text": "Analyze this technical diagram."}
        ]
    }]
)

# High detail - 2.56M pixels, 2048px max dimension
# Low detail - Fastest processing, lower accuracy

Exemplo de Análise de Documentos

OmniDocBench: 0.109 taxa de erro (vs 0.140 para GPT-5.2)

def parse_complex_document(pdf_path):
    """Parse multi-page PDF with tables and figures."""

    # Convert PDF pages to images
    from pdf2image import convert_from_path
    pages = convert_from_path(pdf_path, dpi=300)

    messages = [{"role": "user", "content": []}]

    for i, page in enumerate(pages[:5]):  # First 5 pages
        import io, base64
        buffer = io.BytesIO()
        page.save(buffer, format='PNG')
        img_b64 = base64.b64encode(buffer.getvalue()).decode()

        messages[0]["content"].append({
            "type": "image_url",
            "image_url": {
                "url": f"data:image/png;base64,{img_b64}",
                "detail": "high"
            }
        })

    messages[0]["content"].append({
        "type": "text",
        "text": """
        Extract all data from this document:
        1. Tables with row/column headers
        2. Key figures and their captions
        3. Summary statistics mentioned in text
        Return as structured JSON.
        """
    })

    response = client.chat.completions.create(
        model="gpt-5.4",
        messages=messages
    )

    return response.choices[0].message.content

Análise de Capturas de Tela da UI

def analyze_ui_screenshot(screenshot_path):
    """Analyze UI screenshot for accessibility issues."""

    with open(screenshot_path, 'rb') as f:
        img_b64 = base64.b64encode(f.read()).decode()

    response = client.chat.completions.create(
        model="gpt-5.4",
        messages=[{
            "role": "user",
            "content": [
                {
                    "type": "image_url",
                    "image_url": {
                        "url": f"data:image/png;base64,{img_b64}",
                        "detail": "original"
                    }
                },
                {
                    "type": "text",
                    "text": """
                    Review this UI screenshot for accessibility issues:
                    1. Color contrast problems
                    2. Missing labels or alt text indicators
                    3. Keyboard navigation issues (visible focus states)
                    4. Text size and readability
                    5. Screen reader compatibility concerns

                    List issues with specific locations and severity.
                    """
                }
            ]
        }]
    )

    return response.choices[0].message.content

Fluxos de Trabalho de Contexto Longo

O GPT-5.4 suporta janelas de contexto de até 1M de tokens (experimental).

Contexto Padrão (272K tokens)

# Load large codebase file
with open('large_codebase.py', 'r') as f:
    code = f.read()

response = client.chat.completions.create(
    model="gpt-5.4",
    messages=[
        {"role": "system", "content": "You are a code review assistant."},
        {"role": "user", "content": f"""
        Review this codebase for:
        1. Security vulnerabilities
        2. Performance issues
        3. Code style inconsistencies
        4. Missing error handling

        Code:
        {code}
        """}
    ],
    max_tokens=4000
)

Contexto Estendido (1M tokens)

Configure via parâmetros da API:

response = client.chat.completions.create(
    model="gpt-5.4",
    messages=[
        {"role": "user", "content": large_document}
    ],
    # Extended context configuration
    extra_body={
        "model_context_window": 1048576,  # 1M tokens
        "model_auto_compact_token_limit": 272000  # Auto-compact after 272K
    }
)

# Note: Requests exceeding 272K count at 2x usage rate

Análise de Múltiplos Documentos

def analyze_multiple_documents(documents):
    """Analyze 10+ documents in single context."""

    content_parts = []

    for i, doc in enumerate(documents):
        content_parts.append(f"=== Document {i+1}: {doc['title']} ===\n")
        content_parts.append(doc['content'][:50000])  # Truncate if needed
        content_parts.append("\n\n")

    combined_content = "".join(content_parts)

    response = client.chat.completions.create(
        model="gpt-5.4",
        messages=[{
            "role": "user",
            "content": f"""
            Analyze these documents and provide:
            1. Summary of key themes across all documents
            2. Contradictions or inconsistencies between documents
            3. Action items mentioned in any document
            4. Timeline of events if applicable

            {combined_content}
            """
        }],
        max_tokens=8000
    )

    return response.choices[0].message.content

Codificação e Fluxos de Trabalho de Desenvolvimento

O GPT-5.4 iguala o GPT-5.3-Codex no SWE-Bench Pro (57.7%) com capacidades adicionadas de uso do computador.

Geração de Frontend

def generate_frontend_component(spec):
    """Generate complete React component with styling."""

    prompt = f"""
    Create a complete React component based on this specification:

    {spec}

    Requirements:
    1. Functional component with hooks
    2. TypeScript types for all props and state
    3. Tailwind CSS for styling
    4. Responsive design (mobile, tablet, desktop)
    5. Accessibility (ARIA labels, keyboard navigation)
    6. Unit tests with Jest/React Testing Library

    Return complete code for:
    - Component file (.tsx)
    - Styles (if not Tailwind)
    - Test file (.test.tsx)
    """

    response = client.chat.completions.create(
        model="gpt-5.4",
        messages=[{"role": "user", "content": prompt}],
        max_tokens=6000
    )

    return response.choices[0].message.content

# Example: Theme park simulation (from OpenAI demo)
theme_park_spec = """
Create an interactive isometric theme park simulation game:
- Tile-based path placement
- Ride and scenery construction
- Guest pathfinding and queueing
- Park metrics (money, guests, happiness, cleanliness)
- Browser-playable with Playwright testing
- Generated isometric assets
"""

component_code = generate_frontend_component(theme_park_spec)

Depuração de Problemas Complexos

def debug_with_full_context(error_logs, codebase_files, stack_trace):
    """Debug using full context of logs, code, and stack trace."""

    context = f"""
    ERROR LOGS:
    {error_logs}

    STACK TRACE:
    {stack_trace}

    RELEVANT CODE FILES:
    {codebase_files}

    Task: Identify the root cause and provide a fix.
    Consider:
    1. Race conditions or timing issues
    2. Memory leaks or resource exhaustion
    3. Incorrect assumptions about data flow
    4. Edge cases not handled
    5. External dependency issues

    Provide:
    1. Root cause analysis
    2. Specific code changes needed
    3. Tests to prevent regression
    """

    response = client.chat.completions.create(
        model="gpt-5.4",
        messages=[{"role": "user", "content": context}],
        max_tokens=4000
    )

    return response.choices[0].message.content

Teste Interativo com Playwright

Habilidade experimental do Codex para playtesting de navegador:

def playwright_interactive_debug():
    """
    Use Playwright Interactive for browser playtesting.
    GPT-5.4 can test apps while building them.
    """

    prompt = """
    Build a todo web application and test it as you build:

    1. Create HTML structure
    2. Add CSS styling
    3. Implement JavaScript functionality
    4. After each feature, use Playwright to:
       - Verify element visibility
       - Test user interactions
       - Check state persistence
       - Validate edge cases

    Report any issues found during testing and fix them.
    """

    response = client.chat.completions.create(
        model="gpt-5.4",
        messages=[{"role": "user", "content": prompt}],
        tools=[{"type": "playwright_interactive"}],
        max_tokens=8000
    )

    return response.choices[0].message.content

Respostas em Streaming

O streaming reduz a latência percebida para respostas longas.

Streaming em Python

from openai import OpenAI

client = OpenAI()

stream = client.chat.completions.create(
    model="gpt-5.4",
    messages=[{"role": "user", "content": "Write a detailed explanation of quantum computing."}],
    stream=True
)

for chunk in stream:
    if chunk.choices[0].delta.content:
        print(chunk.choices[0].delta.content, end="", flush=True)

Streaming em Node.js

const stream = await client.chat.completions.create({
    model: 'gpt-5.4',
    messages: [{ role: 'user', content: 'Write a detailed explanation of quantum computing.' }],
    stream: true
});

for await (const chunk of stream) {
    if (chunk.choices[0].delta.content) {
        process.stdout.write(chunk.choices[0].delta.content);
    }
}

Streaming com Contagem de Tokens

def stream_with_usage(stream):
    """Track token usage while streaming."""
    total_tokens = 0

    for chunk in stream:
        if chunk.choices[0].delta.content:
            content = chunk.choices[0].delta.content
            print(content, end="", flush=True)
            total_tokens += len(content) // 4  # Rough estimate

        if chunk.usage:
            print(f"\n\nUsage: {chunk.usage.total_tokens} tokens")

    return total_tokens

Tratamento de Erros e Lógica de Reintentaiva

O código de produção precisa de um tratamento de erros robusto.

Tratamento de Erros Abrangente

from openai import OpenAI, RateLimitError, APIError, AuthenticationError
import time

client = OpenAI()

def make_request_with_retry(messages, max_retries=3):
    """Make request with exponential backoff retry logic."""

    for attempt in range(max_retries):
        try:
            response = client.chat.completions.create(
                model="gpt-5.4",
                messages=messages,
                max_tokens=2000,
                temperature=0.7
            )
            return response

        except RateLimitError as e:
            if attempt == max_retries - 1:
                raise

            wait_time = 2 ** attempt  # 1s, 2s, 4s
            print(f"Rate limited. Waiting {wait_time}s...")
            time.sleep(wait_time)

        except APIError as e:
            if e.status_code >= 500:  # Server error, retry
                if attempt == max_retries - 1:
                    raise
                wait_time = 2 ** attempt
                time.sleep(wait_time)
            else:
                raise  # Client error, don't retry

        except AuthenticationError:
            print("Invalid API key. Check your credentials.")
            raise

        except Exception as e:
            print(f"Unexpected error: {e}")
            raise

    raise Exception("Max retries exceeded")

# Usage
try:
    response = make_request_with_retry([
        {"role": "user", "content": "Hello, GPT-5.4!"}
    ])
    print(response.choices[0].message.content)
except Exception as e:
    print(f"Request failed: {e}")

Tratamento de Timeout

import httpx

# Configure timeout
client = OpenAI(
    timeout=httpx.Timeout(60.0, connect=10.0)  # 60s total, 10s connect
)

try:
    response = client.chat.completions.create(
        model="gpt-5.4",
        messages=[{"role": "user", "content": "Long-running task..."}]
    )
except httpx.TimeoutException:
    print("Request timed out. Consider using streaming or reducing complexity.")

Melhores Práticas de Produção

Usando Apidog para Fluxos de Trabalho de API em Produção

Antes de implantar integrações do GPT-5.4 em produção, estabeleça fluxos de trabalho robustos de teste e monitoramento:

Pipeline de Teste de API:

Interface do Apidog mostrando um pipeline de teste de API abrangente com sucesso e falhas.

Colaboração em Equipe:

Padrão de Integração:

Estratégias de Otimização de Custos

Otimização de Prompt

# Bad: Verbose prompt
bad_prompt = """
Hello! I hope you're doing well. I was wondering if you could possibly help me
with something. I have this code here and I'm not quite sure what it does.
Could you please explain it to me? Here's the code:
""" + code

# Good: Direct prompt
good_prompt = f"Explain what this code does:\n{code}"

# Token savings: ~50 tokens = $0.000125 per request
# At 1M requests/month: $125 savings

Controle do Tamanho da Resposta

# Set max_tokens appropriately
response = client.chat.completions.create(
    model="gpt-5.4",
    messages=[{"role": "user", "content": "Summarize this article."}],
    max_tokens=200  # Don't let it ramble
)

# Use stop sequences
response = client.chat.completions.create(
    model="gpt-5.4",
    messages=[{"role": "user", "content": "List 5 items."}],
    stop=["\n\n", "6."]  # Stop after list
)

Processamento em Lote

# Use Batch API for 50% discount
from openai import OpenAI

client = OpenAI()

# Create batch file
batch_requests = []
for article in articles:
    batch_requests.append({
        "custom_id": article["id"],
        "method": "POST",
        "url": "/v1/chat/completions",
        "body": {
            "model": "gpt-5.4",
            "messages": [{"role": "user", "content": article["content"]}]
        }
    })

# Upload and process
batch_file = client.files.create(
    file=json.dumps(batch_requests),
    purpose="batch"
)

batch = client.batches.create(
    input_file_id=batch_file.id,
    endpoint="/v1/chat/completions",
    completion_window="24h"
)

# 50% cost savings for non-real-time workloads

Cache de Requisições Repetidas

import hashlib
import json

class ResponseCache:
    """Cache identical API responses."""

    def __init__(self):
        self.cache = {}

    def _get_key(self, messages):
        return hashlib.md5(json.dumps(messages).encode()).hexdigest()

    def get_or_create(self, client, messages, **kwargs):
        key = self._get_key(messages)

        if key in self.cache:
            return self.cache[key]

        response = client.chat.completions.create(
            model="gpt-5.4",
            messages=messages,
            **kwargs
        )

        self.cache[key] = response
        return response

# Usage
cache = ResponseCache()
response = cache.get_or_create(client, messages)

Conclusão

O GPT-5.4 abre novas possibilidades para aplicações alimentadas por IA. O uso nativo do computador permite automação de navegador e fluxos de trabalho entre aplicações. A busca de ferramentas reduz os custos em 47%, ao mesmo tempo em que suporta ecossistemas de ferramentas maiores. A visão aprimorada lida com a análise complexa de documentos. E as janelas de contexto de 1M processam bases de código inteiras.

Construir aplicações de produção com o GPT-5.4 requer testes, depuração e documentação robustos da API. O Apidog fornece uma plataforma unificada para todo o ciclo de vida da API.

botão

Seja você construindo agentes de IA, automatizando fluxos de trabalho ou criando recursos voltados para o cliente e alimentados pelo GPT-5.4, ter práticas sólidas de desenvolvimento de API acelera a entrega e reduz bugs.

Comece com completações de chat básicas, depois adicione o uso do computador, a busca de ferramentas e a visão conforme seus casos de uso exigirem. Monitore os custos de perto durante a implantação inicial e otimize os prompts e as estratégias de cache.

FAQ

Como uso o recurso de uso do computador do GPT-5.4?

Use a ferramenta computer em requisições de API. Envie capturas de tela como imagens, receba comandos do computador (clicar, digitar, rolar) em resposta. Execute comandos usando pyautogui ou Playwright, depois envie novas capturas de tela. Repita o ciclo até a conclusão da tarefa. Configure políticas de segurança com base na tolerância a riscos.

O que é busca de ferramentas e como a habilito?

A busca de ferramentas carrega as definições de ferramentas sob demanda, em vez de antecipadamente, reduzindo o uso de tokens em 47%. Habilite fornecendo uma lista leve de ferramentas nas requisições. O modelo solicita as definições completas quando necessário. Funciona automaticamente com servidores MCP.

Como uso a janela de contexto de 1M de tokens?

Configure via parâmetros extra_body: model_context_window: 1048576 e model_auto_compact_token_limit: 272000. Nota: Requisições que excedem 272K tokens contam com uma taxa de uso de 2x. Disponível experimentalmente no Codex.

Qual a diferença entre gpt-5.4 e gpt-5.4-pro?

O GPT-5.4 Pro oferece maior precisão em raciocínios complexos (89.3% vs 82.7% no BrowseComp), mas custa 12x mais ($30/$180 vs $2.50/$15). Use o padrão para a maioria das cargas de trabalho, o Pro para tarefas que exigem máxima precisão.

Como reduzo os custos da API GPT-5.4?

Use entradas em cache (90% de economia), otimize o tamanho do prompt, defina limites de max_tokens, use a API de Lotes (50% de desconto), implemente cache de respostas e escolha níveis de detalhe apropriados para imagens.

O GPT-5.4 pode processar múltiplas imagens em uma única requisição?

Sim. Inclua várias partes de conteúdo image_url em uma única mensagem. Útil para documentos de várias páginas, tarefas de comparação ou capturas de tela sequenciais.

Como lido com limites de taxa em produção?

Implemente lógica de repetição com backoff exponencial (atrasos de 1s, 2s, 4s), use a API de Lotes para processamento em massa, distribua as requisições ao longo do tempo e solicite aumentos de limite para necessidades de alto volume.

Quais linguagens de programação o GPT-5.4 melhor suporta?

O GPT-5.4 se destaca em Python, JavaScript/TypeScript, React, Node.js e tecnologias web comuns. Também é forte em Java, Go, Rust e SQL. Iguala o desempenho do GPT-5.3-Codex (57.7% SWE-Bench Pro).

Como faço streaming de respostas do GPT-5.4?

Defina stream=True nas requisições da API. Itere sobre os chunks e processe cada delta. Reduz a latência percebida para respostas longas.

O GPT-5.4 é adequado para cargas de trabalho de produção?

Sim. O GPT-5.4 tem 33% menos erros factuais que o GPT-5.2, usa tokens de forma mais eficiente e inclui tratamento robusto de erros. Implemente lógica de repetição, monitoramento e rastreamento de custos para implantações em produção.

Pratique o design de API no Apidog

Descubra uma forma mais fácil de construir e usar APIs

Cadastre-se gratuitamenteBaixar