Modelos da OpenAI no Amazon Bedrock

O Amazon Bedrock executa os modelos compatíveis da OpenAI em infraestrutura gerenciada pela AWS. Use este guia para comparar o suporte a recursos da API da OpenAI e se conectar com o SDK da OpenAI. Para configurar a implantação, consulte a documentação da AWS indicada nesta página.

As capacidades dos modelos e a compatibilidade com a API determinam o que seu aplicativo pode fazer. A AWS gerencia o acesso aos modelos, a disponibilidade regional, o roteamento, o faturamento e os controles operacionais da sua implantação no Bedrock.

Como funciona a disponibilidade no Bedrock

Os modelos da OpenAI estão disponíveis por meio de dois endpoints do Amazon Bedrock: bedrock-runtime e bedrock-mantle. Ambos oferecem suporte às APIs Responses e Chat Completions compatíveis com a OpenAI nos modelos suportados, mas os recursos oferecidos são diferentes.

Escolha o endpoint de acordo com as capacidades de que seu aplicativo precisa. Por exemplo, a pesquisa na Web hospedada atualmente exige o Mantle. Consulte as diferenças entre endpoints nesta página e a comparação de endpoints da AWS para saber mais sobre as capacidades específicas do Bedrock e a escolha do endpoint.

O GPT-6 Astra está disponível por meio do Bedrock Runtime e do Mantle em us-west-2 (Oregon). Os exemplos deste guia usam o GPT-5.6 Sol em us-east-2; selecione a Região compatível com o Astra antes de trocar o modelo.

Para obter informações sobre acesso e configuração, consulte o anúncio do GPT-6 Astra e as instruções do endpoint Runtime da AWS.

Faça requisições à API Responses

Estes exemplos usam o SDK da OpenAI com o endpoint Mantle. Selecione a Região da AWS e o ID do modelo para sua implantação:

As bibliotecas cliente com um provedor Bedrock determinam a URL base regional do Mantle a partir da Região da AWS. Os provedores JavaScript, Python, Go e Java usam https://bedrock-mantle.us-east-2.api.aws/openai/v1 nos exemplos deste guia para us-east-2. Os exemplos em Ruby configuram o endpoint /openai/v1 diretamente porque a rota padrão /v1 do provedor não oferece suporte a esse modelo.
Use um ID de modelo do Bedrock com o prefixo openai., como openai.gpt-5.6-sol.

Os exemplos usam openai.gpt-5.6-sol em us-east-2. Para o Runtime, siga as instruções do endpoint da API Responses da AWS para selecionar a URL base e o perfil de inferência. Não reutilize um ID de modelo do Mantle sem verificar os requisitos do Runtime.

O exemplo a seguir usa uma chave de API do Bedrock armazenada como AWS_BEARER_TOKEN_BEDROCK. Consulte Chaves de API do Amazon Bedrock para obter informações sobre como gerar e usar uma chave de API do Bedrock.

Instale o provedor Bedrock opcional para Java antes de usar qualquer um dos exemplos em Java:

12345<dependency>
  <groupId>com.openai</groupId>
  <artifactId>openai-java-bedrock</artifactId>
  <version>4.57.0</version>
</dependency>

Envie uma requisição à API Responses por meio do Amazon Bedrock

JavaScript

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16import OpenAI from "openai";
import { bedrock } from "openai/providers/bedrock";

const client = new OpenAI({
  provider: bedrock({
    region: "us-east-2",
    apiKey: process.env.AWS_BEARER_TOKEN_BEDROCK,
  }),
});

const response = await client.responses.create({
  model: "openai.gpt-5.6-sol",
  input: "Write a haiku about cloud infrastructure.",
});

console.log(response.output_text);

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18import os

from openai import OpenAI
from openai.providers import bedrock

client = OpenAI(
    provider=bedrock(
        region="us-east-2",
        api_key=os.environ["AWS_BEARER_TOKEN_BEDROCK"],
    )
)

response = client.responses.create(
    model="openai.gpt-5.6-sol",
    input="Write a haiku about cloud infrastructure.",
)

print(response.output_text)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32package main

import (
	"context"
	"fmt"
	"os"

	"github.com/openai/openai-go/v3"
	"github.com/openai/openai-go/v3/bedrock"
	"github.com/openai/openai-go/v3/responses"
)

func main() {
	client, err := bedrock.NewClient(context.Background(), bedrock.Config{
		AWSRegion: "us-east-2",
		APIKey:    os.Getenv("AWS_BEARER_TOKEN_BEDROCK"),
	})
	if err != nil {
		panic(err)
	}

	response, err := client.Responses.New(context.Background(), responses.ResponseNewParams{
		Model: "openai.gpt-5.6-sol",
		Input: responses.ResponseNewParamsInputUnion{
			OfString: openai.String("Write a haiku about cloud infrastructure."),
		},
	})
	if err != nil {
		panic(err)
	}
	fmt.Println(response.OutputText())
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27import com.openai.client.OpenAIClient;
import com.openai.client.okhttp.BedrockOpenAIOkHttpClient;
import com.openai.models.responses.ResponseCreateParams;

public final class AmazonBedrockCreateResponseExample {
  private AmazonBedrockCreateResponseExample() {}

  public static void main(String[] args) {
    OpenAIClient client =
        BedrockOpenAIOkHttpClient.builder()
            .awsRegion("us-east-2")
            .apiKey(System.getenv("AWS_BEARER_TOKEN_BEDROCK"))
            .build();

    ResponseCreateParams params =
        ResponseCreateParams.builder()
            .model("openai.gpt-5.6-sol")
            .input("Write a haiku about cloud infrastructure.")
            .build();

    client.responses().create(params).output().stream()
        .flatMap(item -> item.message().stream())
        .flatMap(message -> message.content().stream())
        .flatMap(content -> content.outputText().stream())
        .forEach(text -> System.out.println(text.text()));
  }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24using System.ClientModel;
using OpenAI.Responses;
#pragma warning disable OPENAI001

string key = Environment.GetEnvironmentVariable("AWS_BEARER_TOKEN_BEDROCK")!;
ResponsesClient client = new(
    new ApiKeyCredential(key),
    new ResponsesClientOptions
    {
        Endpoint = new Uri("https://bedrock-mantle.us-east-2.api.aws/openai/v1"),
    }
);

CreateResponseOptions options = new()
{
    Model = "openai.gpt-5.6-sol",
};
options.InputItems.Add(
    ResponseItem.CreateUserMessageItem("Write a haiku about cloud infrastructure.")
);

ResponseResult response = await client.CreateResponseAsync(options);

Console.WriteLine(response.GetOutputText());

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16require "openai"

client = OpenAI::Client.new(
  provider: OpenAI::Providers.bedrock(
    region: "us-east-2",
    base_url: "https://bedrock-mantle.us-east-2.api.aws/openai/v1",
    api_key: ENV.fetch("AWS_BEARER_TOKEN_BEDROCK")
  )
)

response = client.responses.create(
  model: "openai.gpt-5.6-sol",
  input: "Write a haiku about cloud infrastructure."
)

puts(response.output_text)

1
2
3
4
5
6
7curl "https://bedrock-mantle.us-east-2.api.aws/openai/v1/responses" \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer $AWS_BEARER_TOKEN_BEDROCK" \
  -d '{
    "model": "openai.gpt-5.6-sol",
    "input": "Write a haiku about cloud infrastructure."
  }'

Para aplicativos de longa duração, prefira a cadeia de credenciais padrão da AWS a um token bearer estático. Os provedores dos SDKs JavaScript, Python, Go, Java e Ruby obtêm credenciais atualizadas da AWS e assinam cada tentativa de requisição com SigV4. A cadeia pode incluir credenciais configuradas com aws login, perfis compartilhados, funções de cargas de trabalho e credenciais de instâncias ou contêineres.

Instale as dependências opcionais dos exemplos com a cadeia de credenciais da AWS antes de usar esta abordagem:

1234npm install @aws-sdk/credential-provider-node @smithy/hash-node @smithy/signature-v4
pip install 'openai[bedrock]'
go get github.com/openai/openai-go/v3/bedrock
bundle add aws-sdk-core

O SDK .NET atualmente não disponibiliza um provedor Bedrock equivalente nem uma política de autenticação AWS SigV4. Use uma chave de API do Bedrock com .NET ou envie uma requisição HTTP assinada por meio de um cliente com suporte da AWS quando seu aplicativo exigir a cadeia de credenciais da AWS.

Envie uma requisição com credenciais do Bedrock gerenciadas pela AWS

JavaScript

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18import OpenAI from "openai";
import { defaultProvider } from "@aws-sdk/credential-provider-node";
import { bedrock } from "openai/providers/bedrock/aws";

const client = new OpenAI({
  provider: bedrock({
    region: "us-east-2",
    endpoint: "mantle",
    credentialProvider: defaultProvider(),
  }),
});

const response = await client.responses.create({
  model: "openai.gpt-5.6-sol",
  input: "Write a haiku about cloud infrastructure.",
});

console.log(response.output_text);

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16from openai import OpenAI
from openai.providers import bedrock

client = OpenAI(
    provider=bedrock(
        region="us-east-2",
        api_key=None,
    )
)

response = client.responses.create(
    model="openai.gpt-5.6-sol",
    input="Write a haiku about cloud infrastructure.",
)

print(response.output_text)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37package main

import (
	"context"
	"fmt"

	"github.com/aws/aws-sdk-go-v2/config"
	"github.com/openai/openai-go/v3"
	"github.com/openai/openai-go/v3/bedrock"
	"github.com/openai/openai-go/v3/responses"
)

func main() {
	awsConfig, err := config.LoadDefaultConfig(context.Background())
	if err != nil {
		panic(err)
	}

	client, err := bedrock.NewClient(context.Background(), bedrock.Config{
		AWSRegion:              "us-east-2",
		AWSCredentialsProvider: awsConfig.Credentials,
	})
	if err != nil {
		panic(err)
	}

	response, err := client.Responses.New(context.Background(), responses.ResponseNewParams{
		Model: "openai.gpt-5.6-sol",
		Input: responses.ResponseNewParamsInputUnion{
			OfString: openai.String("Write a haiku about cloud infrastructure."),
		},
	})
	if err != nil {
		panic(err)
	}
	fmt.Println(response.OutputText())
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28import com.openai.client.OpenAIClient;
import com.openai.client.okhttp.BedrockOpenAIOkHttpClient;
import com.openai.models.responses.ResponseCreateParams;
import software.amazon.awssdk.auth.credentials.DefaultCredentialsProvider;

public final class AmazonBedrockCreateResponseWithAwsCredentialsExample {
  private AmazonBedrockCreateResponseWithAwsCredentialsExample() {}

  public static void main(String[] args) {
    OpenAIClient client =
        BedrockOpenAIOkHttpClient.builder()
            .awsRegion("us-east-2")
            .awsCredentialsProvider(DefaultCredentialsProvider.create())
            .build();

    ResponseCreateParams params =
        ResponseCreateParams.builder()
            .model("openai.gpt-5.6-sol")
            .input("Write a haiku about cloud infrastructure.")
            .build();

    client.responses().create(params).output().stream()
        .flatMap(item -> item.message().stream())
        .flatMap(message -> message.content().stream())
        .flatMap(content -> content.outputText().stream())
        .forEach(text -> System.out.println(text.text()));
  }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16require "openai"

client = OpenAI::Client.new(
  provider: OpenAI::Providers.bedrock(
    region: "us-east-2",
    base_url: "https://bedrock-mantle.us-east-2.api.aws/openai/v1",
    api_key: nil
  )
)

response = client.responses.create(
  model: "openai.gpt-5.6-sol",
  input: "Write a haiku about cloud infrastructure."
)

puts(response.output_text)

Disponibilidade de recursos da API Responses

Use esta matriz para identificar diferenças em relação à API da OpenAI. A disponibilidade varia conforme o modelo e o endpoint; o suporte a uma API não implica suporte a todas as ferramentas ou modos de resposta.

Capacidade	API da OpenAI	Amazon Bedrock
Geração de texto	Disponível	Disponível
Entrada de imagens	Disponível	Disponível
Entrada de arquivos	Disponível	Disponível
Saídas estruturadas	Disponível	Disponível
Chamada de função	Disponível	Disponível
Chamada assíncrona de ferramentas	Disponível nos modelos compatíveis	Indisponível
Respostas em streaming	Disponível	Disponível
Conexões WebSocket	Disponível	Indisponível
Orientação durante o turno	Disponível nos modelos compatíveis	Indisponível
Janela de contexto	Depende do modelo	Depende do modelo
Esforço de raciocínio	Disponível	Disponível
Atualizações de raciocínio	Disponível nos modelos compatíveis	Não disponível
Modo Pro	Disponível nos modelos compatíveis	Não disponível
Raciocínio persistido	Disponível nos modelos compatíveis	Disponível nos modelos compatíveis
Cache de prompts	Disponível	Disponível
Chamada programática de ferramentas	Disponível nos modelos compatíveis	Não disponível
Múltiplos agentes	Beta nos modelos compatíveis	Não disponível
Ferramentas personalizadas	Disponível	Disponível
`tool_search` no lado do cliente	Disponível	Disponível
Pesquisa na Web hospedada	Disponível	Somente no Mantle
Pesquisa de arquivos hospedada	Disponível	Não disponível
Uso do computador	Disponível	Disponível
Ferramenta de shell	Disponível	Não disponível
Ferramenta de geração de imagens	Disponível	Não disponível
Servidores MCP remotos	Disponível	Não disponível

O Amazon Bedrock não oferece suporte à chamada assíncrona de ferramentas (async: true) nem às atualizações de raciocínio (itens de entrada configuration_update). A orientação durante o turno exige WebSockets e não está disponível em nenhum dos dois endpoints do Bedrock.

O tool_search no lado do cliente é diferente do suporte a ferramentas hospedadas e a servidores MCP remotos. A pesquisa na Web hospedada está disponível pelo Mantle; a pesquisa de arquivos hospedada e os servidores MCP remotos não estão disponíveis.

O Uso do computador está disponível no Runtime e no Mantle para os modelos compatíveis. Seu aplicativo executa ações no computador e retorna os resultados ao modelo; esse recurso não exige um ambiente de execução hospedado no Bedrock.

No Amazon Bedrock, GPT-5.4 e GPT-5.5 oferecem suporte a uma janela de contexto de 1 milhão de tokens; GPT-5.6 Sol, Terra, Luna e GPT-6 Astra oferecem suporte a 1.050.000 tokens. Consulte os cartões dos modelos da OpenAI na documentação da AWS para ver os limites específicos de cada modelo.

Diferenças entre endpoints

Considere estas diferenças da API Responses ao escolher entre Runtime e Mantle:

Recurso	Bedrock Runtime	Mantle
GPT-6 Astra	Disponível	Disponível em `us-west-2` (Oregon)
Uso do computador	Disponível nos modelos compatíveis	Disponível nos modelos compatíveis
Respostas em streaming	Disponível	Disponível
Modo em segundo plano (`background: true`)	Não disponível	Disponível, sujeito às configurações de retenção de dados
Pesquisa na Web hospedada	Não disponível	Disponível nos modelos compatíveis
Continuação com `previous_response_id`	Inclua `model` em todas as solicitações	O modelo pode ser herdado da resposta anterior

O Runtime exige model mesmo quando você fornece previous_response_id. O modo em segundo plano é separado do streaming e não se refere à chamada assíncrona de funções. Consulte a documentação da API Responses da AWS para conhecer o contrato completo do endpoint. Para permissões e configuração de pesquisa na Web, consulte o guia de pesquisa na Web da AWS.

Disponibilidade e operações

A AWS mantém as opções de implantação e a disponibilidade do Amazon Bedrock. Use estas referências para selecionar e configurar sua implantação:

Aspecto gerenciado pela AWS	Documentação da AWS
IDs de modelos e APIs compatíveis	Cartões dos modelos da OpenAI
Disponibilidade de modelos e endpoints por região da AWS	Disponibilidade de modelos e disponibilidade de endpoints
Roteamento geográfico e global de solicitações	Inferência entre regiões
Cotas da conta e solicitações de aumento	Cotas do Amazon Bedrock

Uma região da AWS não é uma jurisdição de residência de dados da OpenAI. Se sua carga de trabalho tiver requisitos de localização, confira as regiões de destino do seu perfil de inferência e os termos aplicáveis da AWS, não apenas a região na URL do endpoint.

Acesso e retenção de dados

O Amazon Bedrock usa controles separados para acesso de operadores e retenção de dados:

Zero acesso de operadores (ZOA) significa que os operadores da AWS não dispõem de nenhum mecanismo técnico para fazer login nos sistemas de computação que sustentam o Mantle ou acessar os dados de clientes nesses sistemas. Consulte a arquitetura de ZOA da AWS.
Zero retenção de dados (ZDR) significa que a AWS não grava dados de solicitações ou respostas em armazenamento durável quando o modo de retenção efetivo é none.

Definir store: false não garante ZDR. Para solicitações à API Responses com modo de retenção efetivo none, a AWS rejeita store: true, e o modo em segundo plano fica indisponível.

Para os modelos da OpenAI no Amazon Bedrock, a AWS não compartilha o conteúdo de solicitações ou respostas com a OpenAI quando o modo de retenção efetivo é default ou none. Consulte a documentação de retenção de dados da AWS para saber mais sobre os modos disponíveis, a elegibilidade e a configuração de contas ou projetos. Consulte Detecção de abuso no Amazon Bedrock para conhecer os requisitos de retenção e as exceções específicos de cada modelo.

Se a AWS detectar aparente CSAM em uma imagem de entrada, poderá mover a entrada ou saída sinalizada para fora do ambiente ZOA e armazená-la e analisá-la apenas para determinar se é CSAM. A AWS também poderá apresentar uma denúncia às autoridades nacionais.

Autenticação e operações

Seu administrador da AWS controla o acesso a contas, modelos e recursos. Consulte a documentação de chaves de API da AWS para saber mais sobre a criação e o ciclo de vida de credenciais, e a documentação do IAM para saber mais sobre identidades e permissões. Os exemplos do SDK da OpenAI nesta página mostram como fornecer essas credenciais; eles não configuram permissões da AWS.

Preços

O uso do Amazon Bedrock é cobrado pela AWS. Os preços do Bedrock nas regiões comerciais correspondem aos preços diretos da OpenAI para serviços equivalentes. O uso de um serviço específico de uma região no Bedrock será cobrado pela mesma tarifa do processamento regional na API da OpenAI. Os termos comerciais da Amazon se aplicam ao uso do Bedrock.

Consulte Preços da API para conhecer os preços diretos da API da OpenAI. Para saber as tarifas do Bedrock, os níveis de serviço compatíveis e as opções de cobrança, consulte Preços do Amazon Bedrock e o cartão do modelo aplicável.

Próximos passos

Para configurar o ChatGPT Work e o Codex, consulte Use o ChatGPT Work e o Codex com o Amazon Bedrock.

Sugestões

Primeiros passos

Conceitos fundamentais

SDKs e CLI

Recursos

APIs legadas

Escolha um modelo

Texto e código

Criação de prompts

Raciocínio

Imagens e vídeo

Tempo real e áudio

Modelos especializados

API de Agentes

SDK de Agentes

ChatKit

Pesquisa e recuperação

Conecte ferramentas e dados

Crie fluxos de trabalho com ferramentas

Computador e código

Mídia

GPT-Live

Realtime API

Desenvolva com voz

Conexões

Processamento de áudio

Entre em produção

Desempenho e qualidade

Custo e taxa de processamento

Segurança e governança

Infraestrutura e acesso

Operações

Conceitos fundamentais

Plan

Build

Test and publish

Conversion specs

Guias

Recursos

Primeiros passos

Guias

File Upload

API

Measurement

Advertiser API

Referência da API

Primeiros passos

Fundamentos

Explorar

Disponível em

Versões

Fluxos de trabalho

Capacidades

Referência

Personalização

Arquivo de configuração

Configuração de agentes

Amplie os recursos do ChatGPT e do Codex

Linux

Windows

Fluxos de trabalho de desenvolvimento

Amplie e automatize

Ambientes

Desenvolva com o Codex

Integrações de terceiros

Referência

Permissões

Codex Security

Segurança cibernética

Primeiros passos

ChatGPT Work

Identidade e autenticação

Acesso, política e modelos do workspace

Controles de plug-ins e conectores

Uso, governança e conformidade

Implantação e provedores de modelos

Comunidade

Blog

Comunidade

Blog