Boas práticas de segurança

Para conhecer as medidas de proteção que a OpenAI aplica, consulte os classificadores de segurança, as verificações de cibersegurança e o monitoramento de desalinhamento. Se o seu aplicativo atende menores de idade, siga também as orientações para aplicativos que atendem menores de 18 anos.

Use nossa API de moderação gratuita

A API de moderação da OpenAI é gratuita e pode ajudar a reduzir a frequência com que conteúdo inseguro aparece nas respostas geradas. Outra opção é desenvolver seu próprio sistema de filtragem de conteúdo para atender às necessidades do seu caso de uso.

Se o seu aplicativo gera texto com a Responses API ou com Chat Completions, você também pode solicitar pontuações de moderação na própria requisição de geração.

Testes adversariais

Recomendamos fazer testes de “red teaming” para verificar se o aplicativo resiste a entradas adversariais. Teste o produto com uma ampla variedade de entradas e comportamentos de usuários. Inclua tanto situações representativas do uso normal quanto tentativas deliberadas de fazer o aplicativo falhar. O aplicativo foge do assunto? Alguém consegue facilmente desviar o recurso de sua finalidade com uma injeção de prompt, por exemplo, dizendo “ignore as instruções anteriores e faça isto em vez disso”?

Supervisão humana (HITL)

Sempre que possível, recomendamos que uma pessoa revise os resultados antes que sejam usados na prática. Essa revisão é especialmente importante em áreas em que um erro pode ter consequências graves e também na geração de código. Quem faz a revisão deve conhecer as limitações do sistema e ter acesso às informações necessárias para verificar os resultados. Por exemplo, se o aplicativo resume anotações, a pessoa responsável pela revisão deve conseguir consultar as anotações originais com facilidade.

Engenharia de prompt

A “engenharia de prompt” pode ajudar a delimitar o assunto e o tom do texto gerado. Isso reduz a chance de o modelo produzir conteúdo indesejado, mesmo que um usuário tente induzi-lo a isso. Oferecer mais contexto ao modelo pode facilitar a obtenção das respostas desejadas. Por exemplo, antes da nova entrada, forneça alguns exemplos de alta qualidade que ilustrem o comportamento esperado.

“Conheça seu cliente” (KYC)

Em geral, exija que os usuários se cadastrem e façam login para acessar o serviço. Permitir o acesso com uma conta existente, como uma conta do Gmail, LinkedIn ou Facebook, pode ajudar, embora essa opção possa ser inadequada para alguns casos de uso. Exigir um cartão de crédito ou um documento de identidade reduz ainda mais o risco.

Restrinja a entrada do usuário e limite os tokens de saída

Limitar a quantidade de texto que o usuário pode inserir no prompt ajuda a evitar a injeção de prompt. Limitar o número de tokens de saída ajuda a reduzir a chance de uso indevido.

Restringir as opções de entrada ou saída reduz as possibilidades de uso indevido do aplicativo, especialmente quando essas opções vêm de fontes confiáveis.

Permitir que o usuário selecione opções em listas suspensas validadas (por exemplo, uma lista de filmes da Wikipédia) pode ser mais seguro do que aceitar texto livre.

Quando possível, pode ser mais seguro retornar conteúdo de um conjunto de materiais já validados no backend do que gerar conteúdo novo. Por exemplo, para responder à dúvida de um cliente, o aplicativo pode indicar o artigo de suporte existente que melhor corresponde à pergunta, em vez de tentar respondê-la do zero.

Permita que os usuários relatem problemas

Em geral, os usuários devem ter acesso fácil a um canal para relatar falhas de funcionamento ou outras preocupações com o comportamento do aplicativo. Você pode, por exemplo, divulgar um endereço de e-mail ou disponibilizar um formulário para abrir chamados. Uma pessoa deve acompanhar esse canal e responder aos relatos conforme necessário.

Entenda e comunique as limitações

Modelos de linguagem podem inventar informações, gerar respostas ofensivas ou reproduzir vieses, entre outras limitações. Por isso, alguns casos de uso podem exigir modificações significativas. Verifique se o modelo é adequado ao seu objetivo e avalie o desempenho da API com uma ampla variedade de entradas possíveis para identificar situações em que esse desempenho pode cair. Leve em conta quem são seus clientes e que tipos de entrada eles vão usar. Certifique-se de que tenham expectativas realistas sobre o desempenho da API.

Implemente identificadores de segurança

Enviar identificadores de segurança nas suas requisições pode ajudar a OpenAI a monitorar e detectar abusos. Se detectarmos alguma violação das políticas no seu aplicativo, esses identificadores nos permitem fornecer informações mais específicas para orientar sua equipe sobre como agir.

Os identificadores de segurança também podem ajudar sua equipe a responder a abusos com mais rapidez. Eles permitem associar a atividade de forma consistente ao usuário final responsável e reduzem a chance de que o uso indevido por uma pessoa prejudique o acesso dos demais usuários da organização.

O identificador de segurança deve ser uma string que identifique cada usuário de forma única. Calcule o hash do nome de usuário ou do endereço de e-mail para evitar o envio de informações que identifiquem a pessoa. Se você oferece uma prévia do produto a usuários que não fizeram login, pode enviar um ID de sessão como alternativa.

Recomendamos o uso de identificadores de segurança em produtos nos quais os usuários interagem individualmente com um modelo, mas eles são opcionais. Para incluir um identificador de segurança nas requisições à API, use o parâmetro safety_identifier.

1
2
3
4
5
6
7
8
9
10
11
12import OpenAI from "openai";

const client = new OpenAI();

const response = await client.chat.completions.create({
  model: "gpt-6-astra",
  messages: [{ role: "user", content: "This is a test" }],
  max_completion_tokens: 5,
  safety_identifier: "user_123456",
});

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

1
2
3
4
5
6
7
8
9
10from openai import OpenAI

client = OpenAI()

response = client.chat.completions.create(
    model="gpt-6-astra",
    messages=[{"role": "user", "content": "This is a test"}],
    max_completion_tokens=5,
    safety_identifier="user_123456",
)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22package main

import (
	"context"
	"fmt"

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

func main() {
	client := openai.NewClient()
	response, err := client.Chat.Completions.New(context.Background(), openai.ChatCompletionNewParams{
		Model:               "gpt-6-astra",
		Messages:            []openai.ChatCompletionMessageParamUnion{openai.UserMessage("This is a test")},
		MaxCompletionTokens: openai.Int(5),
		SafetyIdentifier:    openai.String("user_123456"),
	})
	if err != nil {
		panic(err)
	}
	fmt.Println(response.Choices[0].Message.Content)
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14import com.openai.client.OpenAIClient;
import com.openai.client.okhttp.OpenAIOkHttpClient;
import com.openai.models.chat.completions.ChatCompletionCreateParams;

ChatCompletionCreateParams params =
    ChatCompletionCreateParams.builder()
        .model("gpt-6-astra")
        .addUserMessage("Help me plan a study schedule.")
        .safetyIdentifier("user_1234")
        .build();

client.chat().completions().create(params).choices().stream()
    .flatMap(choice -> choice.message().content().stream())
    .forEach(System.out::println);

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

client = OpenAI::Client.new
completion = client.chat.completions.create(
  model: "gpt-6-astra",
  messages: [
    {
      role: :user,
      content: "Help me plan a study schedule."
    }
  ],
  safety_identifier: "user_1234"
)

puts(completion.choices.fetch(0).message.content)

1
2
3
4
5
6
7
8
9
10
11curl https://api.openai.com/v1/chat/completions \
-H "Content-Type: application/json" \
-H "Authorization: Bearer $OPENAI_API_KEY" \
-d '{
"model": "gpt-6-astra",
"messages": [
{"role": "user", "content": "This is a test"}
],
"max_completion_tokens": 5,
"safety_identifier": "user123456"
}'

Na API de imagens, inclua safety_identifier em cada requisição de geração de imagens (POST /v1/images/generations) e de edição de imagens (POST /v1/images/edits). Envie o identificador como uma propriedade JSON nas requisições JSON ou como um campo de formulário nas requisições multipart de edição de imagens. Use o mesmo identificador estável em todas as requisições de um determinado usuário final na sua organização. O identificador deve ter no máximo 128 caracteres.

O parâmetro user da API de imagens está obsoleto. Para migrar, envie o identificador que você usava em user no campo safety_identifier. A API continua aceitando requisições existentes que usam user. Se você fornecer os dois campos, um valor não vazio de safety_identifier terá prioridade. Se você omitir safety_identifier ou enviar null ou uma string vazia, a API usará user quando disponível.

Nas requisições à Realtime API, envie o mesmo identificador estável que preserva a privacidade do usuário no cabeçalho OpenAI-Safety-Identifier. Ao criar um segredo efêmero para um cliente da Realtime API, inclua o cabeçalho na requisição que o servidor faz para criar o segredo. Assim, o identificador fica vinculado àquela sessão. Se um backend confiável solicitar uma conexão direta via WebSocket ou WebRTC, inclua o cabeçalho na requisição de conexão.

Os identificadores de segurança não são transferidos automaticamente entre APIs ou sessões. Se o seu aplicativo já envia safety_identifier nas requisições à Responses API, envie o mesmo valor estável separadamente em cada requisição à API de imagens e sempre que criar uma sessão da Realtime API ou se conectar a ela.

Revogue chaves de API comprometidas

Se você suspeitar que uma chave de API foi exposta, usada indevidamente ou comprometida de outra forma, revogue-a imediatamente e substitua-a por uma nova chave. Acesse suas configurações de segurança para ver todas as chaves de API e revogar as que estiverem comprometidas.

Orientações sobre CSAM

A OpenAI trabalhou com especialistas em proteção infantil, incluindo o NCMEC e a Thorn, para oferecer aos desenvolvedores orientações práticas sobre como proteger as crianças. Leia as orientações sobre CSAM.