Solicitação e uso da API OpenAI Chat Completion

O OpenAI ChatGPT é um sistema de diálogo de IA muito poderoso; basta inserir um prompt para gerar respostas fluentes e naturais em apenas alguns segundos. O ChatGPT se destaca no setor por sua excelente capacidade de compreensão e geração de linguagem. Hoje, o ChatGPT já é amplamente utilizado em diversos setores e áreas, e sua influência está se tornando cada vez mais significativa. Seja em conversas cotidianas, escrita criativa, consultas profissionais ou programação de código, o ChatGPT pode fornecer uma assistência inteligente surpreendente, melhorando enormemente a eficiência de trabalho e a criatividade humanas. Este documento apresenta principalmente o processo de uso das operações da API OpenAI Chat Completion; com ela, podemos usar facilmente a funcionalidade de diálogo do OpenAI ChatGPT oficial.

GPT-6.1 Sol

Use model: "gpt-6.1-sol" para selecionar este modelo. Suporta saída em streaming, chamada de funções, saída estruturada e entrada de imagens. Durante a primeira semana de abertura, estará disponível apenas para detentores verificados de ACE T1+ (pelo menos 100.000 ACE) ou usuários autorizados; o horário específico de abertura está sujeito ao aviso de acesso no console. Os níveis de raciocínio suportam low, medium, high, xhigh e max; none ou minimal ainda não são suportados. Recomenda-se começar com reasoning_effort: "low". Quando a entrada exceder 272.000 tokens, o preço de contexto longo será aplicado à solicitação inteira; as taxas estão sujeitas ao preço atual no console.

Processo de solicitação

Para usar a API OpenAI Chat Completion, primeiro acesse o Console Ace Data Cloud para obter seu API Token e guarde-o para uso posterior.

Se você ainda não estiver conectado ou registrado, será automaticamente redirecionado para a página de login, onde será convidado a se registrar e entrar; após concluir, retornará automaticamente à página atual. Um único API Token pode chamar todos os serviços da plataforma, sem necessidade de solicitar separadamente para cada serviço. Na primeira solicitação, será concedida uma cota gratuita para experimentação; quando a cota for insuficiente, você poderá recarregar o saldo universal no console.

📘 Documentação completa: OpenAI Chat Completion API →

Uso básico

Em seguida, você pode preencher o conteúdo correspondente na interface, como mostrado na imagem:

Ao usar esta interface pela primeira vez, precisamos preencher pelo menos três conteúdos. Um deles é authorization, que pode ser selecionado diretamente na lista suspensa. Outro parâmetro é model; model é a categoria de modelo do site oficial OpenAI ChatGPT que escolhemos usar. Aqui, temos principalmente 20 modelos, e você pode consultar os modelos que fornecemos para mais detalhes. O último parâmetro é messages; messages é o array de prompts que inserimos. Ele é um array, indicando que vários prompts podem ser enviados ao mesmo tempo. Cada prompt contém role e content, onde role representa o papel do solicitante. Fornecemos três identidades: user, assistant e system. O outro, content, é o conteúdo específico da nossa pergunta. Ao mesmo tempo, você pode observar que há a geração do código de chamada correspondente no lado direito. Você pode copiar o código e executá-lo diretamente, ou clicar diretamente no botão 「Try」 para testar. Parâmetros opcionais comuns:

max_tokens: limita o número máximo de tokens em uma única resposta.
temperature: aleatoriedade da geração, entre 0 e 2; quanto maior o valor, mais divergente.
n: quantas respostas candidatas gerar de uma vez.
response_format: configuração do formato de retorno.

Após a chamada, descobrimos que o resultado retornado é o seguinte:

{
  "id": "chatcmpl-Cmd6uwSxN75F4PAdQSFEO8f2QPs4E",
  "object": "chat.completion",
  "created": 1765706120,
  "model": "gpt-5.5",
  "choices": [
    {
      "index": 0,
      "message": {
        "role": "assistant",
        "content": "Hello! What can I help you with today?",
        "refusal": null,
        "annotations": []
      },
      "finish_reason": "stop"
    }
  ],
  "usage": {
    "prompt_tokens": 7,
    "completion_tokens": 13,
    "total_tokens": 20,
    "prompt_tokens_details": {
      "cached_tokens": 0,
      "audio_tokens": 0
    },
    "completion_tokens_details": {
      "reasoning_tokens": 0,
      "audio_tokens": 0,
      "accepted_prediction_tokens": 0,
      "rejected_prediction_tokens": 0
    }
  },
  "service_tier": "default",
  "system_fingerprint": null
}

O resultado retornado possui vários campos, apresentados a seguir:

id, o ID gerado desta tarefa de conversa, usado para identificar exclusivamente esta tarefa de conversa.
model , o modelo do site oficial OpenAI ChatGPT selecionado.
choices, as informações de resposta fornecidas pelo ChatGPT para o prompt.
usage : informações estatísticas sobre tokens para esta sessão de perguntas e respostas.

Entre eles, choices contém as informações de resposta do ChatGPT, e o choices dentro dele é o ChatGPT, como pode ser visto na imagem.

Pode-se ver que o campo content dentro de choices contém o conteúdo específico da resposta do ChatGPT.

Resposta em streaming

Esta interface também oferece suporte a respostas em streaming, o que é muito útil para integração com páginas web, permitindo que a página web implemente um efeito de exibição palavra por palavra. Se desejar retornar respostas em streaming, você pode alterar o parâmetro stream no cabeçalho da solicitação para true. A modificação é mostrada na imagem; no entanto, o código de chamada precisa ter as alterações correspondentes para oferecer suporte a respostas em streaming.

Após modificar stream para true, a API retornará os dados JSON correspondentes linha por linha. No nível do código, precisamos fazer as modificações correspondentes para obter os resultados linha por linha. Código de chamada de exemplo em Python:

import requests

url = "https://api.acedata.cloud/openai/chat/completions"

headers = {
    "accept": "application/json",
    "authorization": "Bearer {token}",
    "content-type": "application/json"
}

payload = {
    "model": "gpt-4",
    "messages": [{"role":"user","content":"hello"}],
    "stream": True
}

response = requests.post(url, json=payload, headers=headers)
print(response.text)

O efeito de saída é o seguinte:

data: {"choices": [{"delta": {"role": "assistant"}, "index": 0}], "created": 1721007348, "id": "chatcmpl-YzczYjVhNjhjMzMwNDQ5MDkyNGYzOGZjZGE1ZGQ5OGU", "model": "gpt-4", "object": "chat.completion.chunk", "recipient": "all"}

data: {"choices": [{"delta": {"content": "Hi", "role": "assistant"}, "index": 0}], "created": 1721007348, "id": "chatcmpl-YzczYjVhNjhjMzMwNDQ5MDkyNGYzOGZjZGE1ZGQ5OGU", "model": "gpt-4", "object": "chat.completion.chunk", "recipient": "all"}

data: {"choices": [{"delta": {"content": " there", "role": "assistant"}, "index": 0}], "created": 1721007348, "id": "chatcmpl-YzczYjVhNjhjMzMwNDQ5MDkyNGYzOGZjZGE1ZGQ5OGU", "model": "gpt-4", "object": "chat.completion.chunk", "recipient": "all"}

data: {"choices": [{"delta": {"content": "!", "role": "assistant"}, "index": 0}], "created": 1721007348, "id": "chatcmpl-YzczYjVhNjhjMzMwNDQ5MDkyNGYzOGZjZGE1ZGQ5OGU", "model": "gpt-4", "object": "chat.completion.chunk", "recipient": "all"}

data: {"choices": [{"delta": {"content": " How", "role": "assistant"}, "index": 0}], "created": 1721007348, "id": "chatcmpl-YzczYjVhNjhjMzMwNDQ5MDkyNGYzOGZjZGE1ZGQ5OGU", "model": "gpt-4", "object": "chat.completion.chunk", "recipient": "all"}

data: {"choices": [{"delta": {"content": " can", "role": "assistant"}, "index": 0}], "created": 1721007348, "id": "chatcmpl-YzczYjVhNjhjMzMwNDQ5MDkyNGYzOGZjZGE1ZGQ5OGU", "model": "gpt-4", "object": "chat.completion.chunk", "recipient": "all"}

data: {"choices": [{"delta": {"content": " I", "role": "assistant"}, "index": 0}], "created": 1721007348, "id": "chatcmpl-YzczYjVhNjhjMzMwNDQ5MDkyNGYzOGZjZGE1ZGQ5OGU", "model": "gpt-4", "object": "chat.completion.chunk", "recipient": "all"}

data: {"choices": [{"delta": {"content": " assist", "role": "assistant"}, "index": 0}], "created": 1721007348, "id": "chatcmpl-YzczYjVhNjhjMzMwNDQ5MDkyNGYzOGZjZGE1ZGQ5OGU", "model": "gpt-4", "object": "chat.completion.chunk", "recipient": "all"}

data: {"choices": [{"delta": {"content": " you", "role": "assistant"}, "index": 0}], "created": 1721007348, "id": "chatcmpl-YzczYjVhNjhjMzMwNDQ5MDkyNGYzOGZjZGE1ZGQ5OGU", "model": "gpt-4", "object": "chat.completion.chunk", "recipient": "all"}

data: {"choices": [{"delta": {"content": " today", "role": "assistant"}, "index": 0}], "created": 1721007348, "id": "chatcmpl-YzczYjVhNjhjMzMwNDQ5MDkyNGYzOGZjZGE1ZGQ5OGU", "model": "gpt-4", "object": "chat.completion.chunk", "recipient": "all"}

data: {"choices": [{"delta": {"content": "?", "role": "assistant"}, "index": 0}], "created": 1721007348, "id": "chatcmpl-YzczYjVhNjhjMzMwNDQ5MDkyNGYzOGZjZGE1ZGQ5OGU", "model": "gpt-4", "object": "chat.completion.chunk", "recipient": "all"}

data: {"choices": [{"delta": {"role": "assistant"}, "index": 0}], "created": 1721007348, "id": "chatcmpl-YzczYjVhNjhjMzMwNDQ5MDkyNGYzOGZjZGE1ZGQ5OGU", "model": "gpt-4", "object": "chat.completion.chunk", "recipient": "all"}

data: {"choices": [{"delta": {"role": "assistant"}, "finish_reason": "stop", "index": 0}], "created": 1721007349, "id": "chatcmpl-YzczYjVhNjhjMzMwNDQ5MDkyNGYzOGZjZGE1ZGQ5OGU", "model": "gpt-4", "object": "chat.completion.chunk", "recipient": "all"}

data: [DONE]

Pode-se ver que há muitos data na resposta, e os choices dentro de data são o conteúdo mais recente da resposta, consistente com o conteúdo apresentado acima. choices é o novo conteúdo da resposta, e você pode integrá-lo ao seu sistema de acordo com o resultado. Ao mesmo tempo, o fim da resposta em fluxo é determinado com base no conteúdo de data; se o conteúdo for [DONE], isso indica que a resposta em fluxo foi completamente finalizada. O resultado data retornado possui vários campos, apresentados a seguir:

id, o ID da tarefa desta conversa gerada, usado para identificar exclusivamente esta tarefa de conversa.
model , o modelo selecionado no site oficial do OpenAI ChatGPT.
choices, as informações de resposta fornecidas pelo ChatGPT para a pergunta.

JavaScript também é suportado; por exemplo, o código de chamada em fluxo do Node.js é o seguinte:

const options = {
  method: "post",
  headers: {
    accept: "application/json",
    authorization: "Bearer {token}",
    "content-type": "application/json",
  },
  body: JSON.stringify({
    model: "gpt-4",
    messages: [{ role: "user", content: "hello" }],
    stream: true,
  }),
};

fetch("https://api.acedata.cloud/openai/chat/completions", options)
  .then((response) => response.json())
  .then((response) => console.log(response))
  .catch((err) => console.error(err));

Código de exemplo em Java:

JSONObject jsonObject = new JSONObject();
jsonObject.put("model", "gpt-4");
jsonObject.put("messages", [{"role":"user","content":"hello"}]);
jsonObject.put("stream", true);
MediaType mediaType = "application/json; charset=utf-8".toMediaType();
RequestBody body = jsonObject.toString().toRequestBody(mediaType);
Request request = new Request.Builder()
  .url("https://api.acedata.cloud/openai/chat/completions")
  .post(body)
  .addHeader("accept", "application/json")
  .addHeader("authorization", "Bearer {token}")
  .addHeader("content-type", "application/json")
  .build();

OkHttpClient client = new OkHttpClient();
Response response = client.newCall(request).execute();
System.out.print(response.body!!.string())

Outras linguagens podem ser adaptadas separadamente, e o princípio é o mesmo.

Conversa com múltiplas rodadas

Se você quiser integrar a funcionalidade de conversa com múltiplas rodadas, será necessário enviar várias perguntas no campo messages; um exemplo específico de várias perguntas é mostrado na imagem abaixo:

Código de chamada de exemplo em Python:

import requests

url = "https://api.acedata.cloud/openai/chat/completions"

headers = {
    "accept": "application/json",
    "authorization": "Bearer {token}",
    "content-type": "application/json"
}

payload = {
    "model": "gpt-4",
    "messages": [{"role":"user","content":"Hello"},{"role":"assistant","content":"Hi! How can I assist you today?"},{"role":"user","content":"What I say just now?"}]
}

response = requests.post(url, json=payload, headers=headers)
print(response.text)

Ao enviar várias palavras de consulta, é possível implementar facilmente conversas de múltiplos turnos, podendo obter a seguinte resposta:

{
  "choices": [
    {
      "index": 0,
      "message": {
        "role": "assistant",
        "content": "You said, \"Hello.\""
      },
      "finish_reason": "stop"
    }
  ],
  "created": 1721323012,
  "id": "chatcmpl-NWZmOTA5MDlkZjBjNDRjNGEwMzRjYzA5NmM1MzQwMWY",
  "model": "gpt-4",
  "object": "chat.completion.chunk",
  "recipient": "all",
  "usage": {
    "prompt_tokens": 31,
    "completion_tokens": 6,
    "total_tokens": 37
  }
}

Pode-se ver que as informações contidas em choices são consistentes com o conteúdo do uso básico, e isso contém o conteúdo específico da resposta do ChatGPT para várias conversas, permitindo assim responder às perguntas correspondentes com base em vários conteúdos de conversa.

Integração com OpenAI-Python

A API OpenAI Chat Completion mantém compatibilidade com a interface oficial da OpenAI, sendo possível integrar diretamente usando o SDK oficial OpenAI-Python. Este artigo apresentará brevemente a forma de uso.

Primeiro, é necessário configurar um ambiente local de Python; esse processo pode ser pesquisado no Google.
Baixe e instale o ambiente de desenvolvimento, por exemplo, o editor VSCode.
Configure as variáveis de ambiente da OpenAI.

Na pasta do projeto, crie e salve um arquivo chamado .env
Conteúdo do arquivo .env:

OPENAI_API_KEY="sk-xxx"
OPENAI_BASE_URL="https://api.acedata.cloud/openai"  # Novamente: se você usar a chave da OpenAI oficial, não use este endereço.

Substitua sk-xxx pela sua própria chave. OPENAI_BASE_URL é a interface de proxy para acessar a OpenAI.

Instale os pacotes de dependência do projeto

pip install openai

No Mac OS, o comando é:

pip3 install openai

Crie um arquivo de código-fonte de exemplo

Suponha que criamos um código de exemplo index.py, cujo conteúdo específico é o seguinte:

import os
from openai import OpenAI

client = OpenAI(api_key=os.environ.get("OPENAI_API_KEY"))

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

print(response.text)

Modelos com acesso à internet

Os modelos gpt-3.5-browsing e gpt-4-browsing são diferentes dos outros modelos: eles podem realizar pesquisas na internet com base nas palavras de consulta e retornar os resultados da pesquisa na internet com os ajustes apropriados. Este artigo demonstrará a funcionalidade de acesso à internet por meio de um exemplo específico. Em seguida, é possível preencher o conteúdo correspondente na interface da API OpenAI Chat Completion, como mostrado na imagem:

Ao mesmo tempo, você pode observar que há geração de código de chamada correspondente no lado direito; você pode copiar o código e executá-lo diretamente, ou clicar diretamente no botão «Try» para testar.

Após a chamada, descobrimos que o resultado retornado é o seguinte:

{
  "choices": [
    {
      "index": 0,
      "message": {
        "role": "assistant",
        "content": "For the latest news in China today, you can check major news websites such as:\n\n- [BBC News China](https://www.bbc.com/news/world/asia/china)\n- [CNN China News](https://edition.cnn.com/china)\n- [Reuters China](https://www.reuters.com/news/archive/china-news)\n\nThese sources will have up-to-date information on current events in China."
      },
      "finish_reason": "stop"
    }
  ],
  "created": 1721009347,
  "id": "chatcmpl-YzA0M2RjZDVkYThlNDkxNTkzOThmZWQ4OGMzNzdhNzA",
  "model": "gpt-4-browsing",
  "object": "chat.completion.chunk",
  "recipient": "all",
  "usage": {
    "prompt_tokens": 325,
    "completion_tokens": 82,
    "total_tokens": 407
  }
}

Pode-se ver que as informações de resposta em choices foram obtidas com base em consultas na internet e também são fornecidos links relacionados. As informações de resposta em choices devem ser renderizadas por meio da sintaxe markdown para obter a melhor experiência; por fim, isso também demonstra a grande vantagem da funcionalidade de acesso à internet do nosso modelo.

Modelo visual

gpt-4o é um grande modelo de linguagem multimodal desenvolvido pela OpenAI, que adiciona capacidade de compreensão visual com base no GPT-4. Este modelo pode processar simultaneamente entradas de texto e imagem, realizando compreensão e geração multimodais. O processamento de texto usando o modelo gpt-4o é consistente com o conteúdo de uso básico acima. A seguir, será apresentado brevemente como usar a capacidade de processamento de imagens do modelo. A capacidade de processamento de imagens do modelo gpt-4o é usada principalmente adicionando um campo type com base no conteúdo original de content. Por meio desse campo, é possível saber se o que foi enviado é texto ou imagem, utilizando assim a capacidade de processamento de imagens do modelo gpt-4o. A seguir, será explicado principalmente como chamar essa funcionalidade por meio de Curl e Python.

Método de script Curl

curl -X POST 'https://api.acedata.cloud/openai/chat/completions' \
-H 'accept: application/json' \
-H 'authorization: Bearer {token}' \
-H 'content-type: application/json' \
-d '{
    "model": "gpt-4o",
    "messages": [
      {
        "role": "user",
        "content": [
          {
            "type": "text",
            "text": "What'\''s in this image?"
          },
          {
            "type": "image_url",
            "image_url": {
              "url": "https://upload.wikimedia.org/wikipedia/commons/thumb/d/dd/Gfp-wisconsin-madison-the-nature-boardwalk.jpg/2560px-Gfp-wisconsin-madison-the-nature-boardwalk.jpg"
            }
          }
        ]
      }
    ]
  }'

Método de script Python

import requests

url = "https://api.acedata.cloud/openai/chat/completions"

headers = {
    "accept": "application/json",
    "authorization": "Bearer {token}",
    "content-type": "application/json"
}

payload = {
    "model": "gpt-4o",
    "messages": [
        {
            "role": "user",
            "content": [
                {
                    "type": "text", "text": "What's in this image?"
                },
                {
                    "type": "image_url",
                    "image_url": {
                        "url": "https://upload.wikimedia.org/wikipedia/commons/thumb/d/dd/Gfp-wisconsin-madison-the-nature-boardwalk.jpg/2560px-Gfp-wisconsin-madison-the-nature-boardwalk.jpg"
                    }
                },
            ],
        }
    ]
}

response = requests.post(url, json=payload, headers=headers)
print(response.text)

Em seguida, é possível obter o resultado abaixo. As informações dos campos no resultado são consistentes com as do texto acima, especificamente como segue:

{
  "id": "chatcmpl-123",
  "object": "chat.completion",
  "created": 1677652288,
  "model": "gpt-4-vision-preview",
  "system_fingerprint": "fp_44709d6fcb",
  "choices": [
    {
      "index": 0,
      "message": {
        "role": "assistant",
        "content": "\n\nThis image shows a wooden boardwalk extending through a lush green marshland."
      },
      "logprobs": null,
      "finish_reason": "stop"
    }
  ],
  "usage": {
    "prompt_tokens": 9,
    "completion_tokens": 12,
    "total_tokens": 21
  }
}

Pode-se ver que o conteúdo da resposta é baseado na imagem, portanto, por meio das duas formas acima, é possível usar facilmente as capacidades de processamento de texto e imagem do modelo gpt-4-vision. Além do gpt-4o, há também um modelo de menor custo, chamado gpt-4o-mini. O gpt-4o-mini é a mais recente geração de modelos de linguagem de grande porte desenvolvida pela OpenAI. Ele não apenas responde rapidamente, como também tem um preço mais baixo e também oferece suporte multimodal. Para o uso da funcionalidade vision, consulte o conteúdo acima sobre o uso do modelo gpt-4o.

Modelo de geração de imagens GPT-4o

Gerar imagens com base em uma imagem de referência

Abaixo está um exemplo de geração de uma imagem de estilo personalizado com base em uma imagem. Primeiro, vamos observar a imagem que inserimos, conforme mostrado abaixo:

Pode-se ver que a imagem de referência é uma imagem de uma pessoa real. Podemos fazê-la mudar para um estilo diferente, por exemplo, transformá-la em uma imagem de estilo anime. O exemplo específico de solicitação é:

{
  "model": "gpt-4o-image",
  "messages": [
    {
      "role": "user",
      "content": [
        {
          "type": "text",
          "text": "生成动漫风格的图片，并且带上个帽子"
        },
        {
          "type": "image_url",
          "image_url": {
            "url": "https://cdn.acedata.cloud/qzx2z1.png"
          }
        }
      ]
    }
  ],
  "stream": false
}

Resultado de exemplo:

{
  "id": "chatcmpl-89DPQxbLuyRNzH5YLCPYM5WElV3dm",
  "object": "chat.completion",
  "created": 1781020664,
  "model": "gpt-4o-image",
  "choices": [
    {
      "index": 0,
      "message": {
        "role": "assistant",
        "content": "\n\n> 🎨 生成中...\n\n![https://platform.cdn.acedata.cloud/20260609/0f7b6cf1b14843b1bab8e261fe5765b3.png](https://platform.cdn.acedata.cloud/20260609/0f7b6cf1b14843b1bab8e261fe5765b3.png)\n\n[点击下载](https://platform.cdn.acedata.cloud/download/20260609/0f7b6cf1b14843b1bab8e261fe5765b3.png)"
      },
      "logprobs": null,
      "finish_reason": "stop"
    }
  ],
  "usage": {
    "prompt_tokens": 100,
    "completion_tokens": 122,
    "total_tokens": 222,
    "prompt_tokens_details": {
      "text_tokens": 93,
      "cached_tokens_details": {}
    },
    "completion_tokens_details": {}
  }
}

Entre eles, o message.content dentro de choices é o resultado completo da conversa gerada, e a imagem está incluída nele no formato Markdown (o link da imagem é um endereço temporário, faça o download e salve-a a tempo). Pode-se ver que a imagem gerada é de fato no estilo anime, especificamente como mostrado abaixo:

Gerar imagem apenas com texto

Podemos usar um prompt para gerar uma imagem e retorná-la para nós como resultado conversacional. A seguir, usaremos 创建一张未来城市日落的图片 como exemplo. O exemplo específico é:

{
  "model": "gpt-4o-image",
  "messages": [
    {
      "role": "user",
      "content": [
        {
          "type": "text",
          "text": "创建一张未来城市日落的图片"
        }
      ]
    }
  ],
  "stream": false
}

Resultado de exemplo:

{
  "id": "chatcmpl-89DqkpQoPGkQqJ6kPKMKWejjLXVxQ",
  "object": "chat.completion",
  "created": 1781020587,
  "model": "gpt-4o-image",
  "choices": [
    {
      "index": 0,
      "message": {
        "role": "assistant",
        "content": "\n\n> 🎨 生成中...\n\n![https://platform.cdn.acedata.cloud/20260609/ed2cca68732540fc99162ddc10ddc153.png](https://platform.cdn.acedata.cloud/20260609/ed2cca68732540fc99162ddc10ddc153.png)\n\n[点击下载](https://platform.cdn.acedata.cloud/download/20260609/ed2cca68732540fc99162ddc10ddc153.png)"
      },
      "logprobs": null,
      "finish_reason": "stop"
    }
  ],
  "usage": {
    "prompt_tokens": 17,
    "completion_tokens": 104,
    "total_tokens": 121,
    "prompt_tokens_details": {
      "text_tokens": 10,
      "cached_tokens_details": {}
    },
    "completion_tokens_details": {}
  }
}

Pode-se ver que o resultado está de acordo com o prompt, especificamente como mostrado abaixo:

Gerar uma imagem a partir de várias imagens

Também podemos usar várias imagens de referência para gerar uma imagem. Por exemplo, usando uma imagem de um homem bonito e uma imagem de café, podemos usar essas duas imagens para gerar uma imagem de um homem bonito tomando café. Abaixo estão as imagens de referência específicas:

A seguir, usaremos 生成男生举着咖啡，并且马上要喝的样子 como exemplo. O exemplo específico é:

{
  "model": "gpt-4o-image",
  "messages": [
    {
      "role": "user",
      "content": [
        {
          "type": "text",
          "text": "Gere um homem segurando café e prestes a bebê-lo"
        },
        {
          "type": "image_url",
          "image_url": {
            "url": "https://cdn.acedata.cloud/pqquv3.jpg"
          }
        },
        {
          "type": "image_url",
          "image_url": {
            "url": "https://cdn.acedata.cloud/h8j2i0.jpg"
          }
        }
      ]
    }
  ],
  "stream": false
}

Resultado de exemplo:

{
  "id": "chatcmpl-89DnHbbzOIQvU1VzJrNjzMU8BRUgG",
  "object": "chat.completion",
  "created": 1781021018,
  "model": "gpt-4o-image",
  "choices": [
    {
      "index": 0,
      "message": {
        "role": "assistant",
        "content": "\n\n> 🎨 Gerando...\n\n![https://platform.cdn.acedata.cloud/20260610/f1d9ddee3c304230a9f92929f04b95be.png](https://platform.cdn.acedata.cloud/20260610/f1d9ddee3c304230a9f92929f04b95be.png)\n\n[Clique para baixar](https://platform.cdn.acedata.cloud/download/20260610/f1d9ddee3c304230a9f92929f04b95be.png)"
      },
      "logprobs": null,
      "finish_reason": "stop"
    }
  ],
  "usage": {
    "prompt_tokens": 193,
    "completion_tokens": 116,
    "total_tokens": 309,
    "prompt_tokens_details": {
      "text_tokens": 186,
      "cached_tokens_details": {}
    },
    "completion_tokens_details": {}
  }
}

Pode-se ver que o resultado gerado de fato combina as duas imagens para gerar o resultado; abaixo está o resultado específico:

Tratamento de erros

Ao chamar a API, caso ocorra um erro, a API retornará o código de erro e as informações correspondentes. Por exemplo:

400 token_mismatched: Bad request, possivelmente devido a parâmetros ausentes ou inválidos.
400 api_not_implemented: Bad request, possivelmente devido a parâmetros ausentes ou inválidos.
401 invalid_token: Não autorizado, token de autorização inválido ou ausente.
429 too_many_requests: Solicitações em excesso, você excedeu o limite de taxa.
500 api_error: Erro interno do servidor, algo deu errado no servidor.

Exemplo de resposta de erro

{
  "success": false,
  "error": {
    "code": "api_error",
    "message": "fetch failed"
  },
  "trace_id": "2cf86e86-22a4-46e1-ac2f-032c0f2a4e89"
}

Conclusão

Por meio deste documento, você já aprendeu como usar a OpenAI Chat Completion API para implementar facilmente a funcionalidade de conversação do OpenAI ChatGPT oficial. Esperamos que este documento possa ajudá-lo a integrar e usar melhor esta API. Se tiver alguma dúvida, entre em contato com nossa equipe de suporte técnico a qualquer momento.

Primeiros passos

Chat AI

Imagem AI

Vídeo AI

Áudio AI

Web e Dados

CAPTCHA

Identidade

Coding

Mais guias

Solicitação e uso da API OpenAI Chat Completion

GPT-6.1 Sol

Processo de solicitação

Uso básico

Resposta em streaming

Conversa com múltiplas rodadas

Integração com OpenAI-Python

Modelos com acesso à internet

Modelo visual

Modelo de geração de imagens GPT-4o

Gerar imagens com base em uma imagem de referência

Gerar imagem apenas com texto

Gerar uma imagem a partir de várias imagens

Tratamento de erros

Exemplo de resposta de erro

Conclusão

​GPT-6.1 Sol

​Processo de solicitação

​Uso básico

​Resposta em streaming

​Conversa com múltiplas rodadas

​Integração com OpenAI-Python

​Modelos com acesso à internet

​Modelo visual

​Modelo de geração de imagens GPT-4o

​Gerar imagens com base em uma imagem de referência

​Gerar imagem apenas com texto

​Gerar uma imagem a partir de várias imagens

​Tratamento de erros

​Exemplo de resposta de erro

​Conclusão

GPT-6.1 Sol

Processo de solicitação

Uso básico

Resposta em streaming

Conversa com múltiplas rodadas

Integração com OpenAI-Python

Modelos com acesso à internet

Modelo visual

Modelo de geração de imagens GPT-4o

Gerar imagens com base em uma imagem de referência

Gerar imagem apenas com texto

Gerar uma imagem a partir de várias imagens

Tratamento de erros

Exemplo de resposta de erro

Conclusão