Proveniência de conteúdo

Use a API de proveniência de conteúdo para verificar se uma imagem ou um arquivo de áudio contém sinais de proveniência da OpenAI que a API reconhece. Envie um arquivo para POST /v1/content_provenance_checks para receber os resultados da verificação na mesma resposta. Use esses sinais em fluxos de trabalho de revisão de conteúdo, checagem de fatos, rotulagem, confiança e segurança.

Para verificar um arquivo no navegador, use a ferramenta disponível em openai.com/verify.

Para consultar os parâmetros da requisição e os schemas de resposta, veja a referência da API de proveniência de conteúdo.

Para verificar textos, solicite acesso. No momento, a verificação de textos está disponível apenas para organizações aprovadas, entre elas instituições de pesquisa em IA e instituições acadêmicas. A OpenAI analisa cada solicitação individualmente.

Quais sinais de proveniência a API verifica

A API procura os seguintes sinais nos arquivos compatíveis:

Os metadados C2PA fornecem mais informações sobre a origem do arquivo. Editar, converter ou compartilhar um arquivo pode remover seus metadados. A marca-d’água SynthID faz parte da própria imagem ou do próprio áudio e pode permanecer após algumas transformações.

A API verifica os sinais de proveniência da OpenAI que ela reconhece. Ela não é um detector de IA de uso geral e não identifica conteúdo gerado por todos os sistemas de IA. Marcas-d’água visíveis e rótulos são distintos dos sinais de proveniência que a API verifica.

Como verificar um arquivo

Use o SDK da OpenAI para enviar uma imagem ou um arquivo de áudio no campo file. O SDK monta a requisição multipart e lê a chave de API da variável de ambiente OPENAI_API_KEY.

1
2
3
4
5
6
7
8
9
10
11
12import { createReadStream } from "node:fs";
import OpenAI, { toStreamingFile } from "openai";

const client = new OpenAI();

const result = await client.contentProvenanceChecks.create({
  file: toStreamingFile(createReadStream("myimage.png"), "myimage.png", {
    type: "image/png",
  }),
});

console.log(result);

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

client = OpenAI()

with open("./example.png", "rb") as image:
    result = client.content_provenance_checks.create(
        file=("example.png", image, "image/png"),
    )

print(result)

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
31package main

import (
	"context"
	"fmt"
	"os"

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

func main() {
	client := openai.NewClient()

	image, err := os.Open("./example.png")
	if err != nil {
		panic(err)
	}
	defer image.Close()

	result, err := client.ContentProvenanceChecks.New(
		context.Background(),
		openai.ContentProvenanceCheckNewParams{
			File: openai.File(image, "example.png", "image/png"),
		},
	)
	if err != nil {
		panic(err)
	}

	fmt.Println(result)
}

1
2
3
4
5
6
7
8
9
10import com.openai.client.okhttp.OpenAIOkHttpClient;
import com.openai.models.contentprovenancechecks.ContentProvenanceCheckCreateParams;
import java.nio.file.Path;

var result =
    client
        .contentProvenanceChecks()
        .create(
            ContentProvenanceCheckCreateParams.builder().file(Path.of("myimage.png")).build());
System.out.println(result);

1
2
3
4
5
6
7
8require "openai"
require "pathname"

client = OpenAI::Client.new
image = OpenAI::FilePart.new(Pathname("./example.png"), content_type: "image/png")
result = client.content_provenance_checks.create(file: image)

puts result

1
2
3curl https://api.openai.com/v1/content_provenance_checks \
  -H "Authorization: Bearer $OPENAI_API_KEY" \
  -F "file=@./example.png;type=image/png"

Use as seguintes versões do SDK da OpenAI ou versões posteriores: 2.52.0 para Python, 3.49.0 para Go e 0.75.0 para Ruby.

Para verificar um áudio Opus, use o mesmo endpoint e defina o tipo de mídia do arquivo enviado como audio/ogg:

123curl https://api.openai.com/v1/content_provenance_checks \
  -H "Authorization: Bearer $OPENAI_API_KEY" \
  -F "file=@./example.opus;type=audio/ogg"

A resposta contém o resultado final da verificação. Este é um exemplo de resposta para uma imagem:

1234567891011121314151617181920{
  "object": "content_provenance_check",
  "created_at": 1778000000,
  "results": [
    {
      "type": "c2pa",
      "outcome": "detected",
      "validation_state": "trusted",
      "issuer": "OpenAI OpCo, LLC",
      "model": "gpt-image",
      "generated_at": "2026-07-27T18:34:12Z"
    },
    {
      "type": "synthid",
      "outcome": "not_detected",
      "model": null,
      "generated_at": null
    }
  ]
}

O campo object identifica a resposta, e created_at indica quando a verificação foi criada, em tempo Unix expresso em segundos. As entradas em results dependem do arquivo enviado. Para imagens, a resposta inclui resultados de C2PA e SynthID. Para áudio, inclui um resultado de SynthID. A API omite as verificações que não se aplicam ao arquivo em vez de retornar not_detected.

A API conclui a verificação antes de responder. Você não precisa criar uma tarefa em segundo plano, consultar outro endpoint periodicamente nem enviar o arquivo para a API de arquivos.

Se uma requisição falhar, confira o código de status HTTP e, se disponível, o campo error.code. A API retorna 400 se o arquivo estiver malformado, for incompatível ou estiver bloqueado. Organizações sem acesso recebem 404. Requisições que excedem o limite de taxa recebem 429. Repita a requisição apenas em caso de falhas temporárias, como quando o limite de taxa é atingido ou ocorre um erro no servidor. Para orientações gerais, consulte os códigos de erro da API.

Como interpretar os resultados da verificação

Analise separadamente cada entrada aplicável em results. Os resultados de imagens incluem entradas de C2PA e SynthID, enquanto os de áudio incluem uma entrada de SynthID. A resposta não inclui um campo outcome no nível superior.

Resultados de C2PA

O resultado de C2PA descreve o estado das credenciais de conteúdo de uma imagem:

12345678{
  "type": "c2pa",
  "outcome": "detected",
  "validation_state": "trusted",
  "issuer": "OpenAI OpCo, LLC",
  "model": "gpt-image",
  "generated_at": "2026-07-27T18:34:12Z"
}

Interprete os campos da seguinte forma:

• outcome indica se a verificação detectou credenciais de geração por IA emitidas pela OpenAI. Os valores possíveis são detected e not_detected.
• validation_state indica o estado do manifesto: trusted, valid, invalid ou not_present.
• issuer identifica o emissor do manifesto quando essa informação está disponível.
• model identifica o modelo que gerou o conteúdo quando essa informação está disponível.
• generated_at indica quando o conteúdo foi gerado, se essa informação estiver disponível.

O resultado só é detected quando um manifesto com estado trusted ou valid identifica a OpenAI como emissora e inclui uma ação de geração por IA. Se o manifesto for de terceiros, não incluir uma ação de geração por IA ou tiver o estado invalid, ou se não houver manifesto (not_present), o resultado será not_detected. Os campos issuer e validation_state ainda podem fornecer informações sobre o manifesto mesmo quando o resultado é not_detected.

Não considere um manifesto com estado invalid uma evidência confiável de proveniência. O resultado not_present indica que não há manifesto C2PA disponível para a imagem.

Resultados de SynthID

O resultado de SynthID indica se o verificador detectou uma marca-d’água compatível na imagem ou no arquivo de áudio:

123456{
  "type": "synthid",
  "outcome": "detected",
  "model": null,
  "generated_at": null
}

O resultado detected indica que o arquivo contém uma marca-d’água reconhecida. O resultado not_detected indica que o verificador não detectou essa marca-d’água. Isso não descarta a possibilidade de o conteúdo ter sido gerado ou modificado por IA. Os campos model e generated_at indicam, respectivamente, qual modelo gerou o conteúdo e quando ele foi gerado, se essas informações estiverem disponíveis. Qualquer um dos campos pode ter o valor null.

Formatos de arquivo e limites de envio

Por padrão, a API aceita os seguintes formatos de arquivo:

• Imagens: PNG, JPEG, WebP e GIF.
• Áudio: MP3, Opus, AAC, FLAC, WAV e PCM.

Cada arquivo enviado deve ter no máximo 50 MiB. O áudio deve ter no máximo 60 segundos de duração após a decodificação.

Defina o tipo de mídia da parte file que contém o arquivo enviado. Use image/gif para GIF, image/png para imagens PNG ou audio/ogg para áudio Opus. Não adicione um campo type separado nem defina manualmente o cabeçalho de tipo de conteúdo da requisição como multipart/form-data. No curl, a opção -F define o tipo de conteúdo da requisição e o delimitador das partes. Envie um arquivo por requisição.

Limites de taxa

Limites de taxa rigorosos ajudam a proteger a API contra uso indevido. As organizações podem solicitar limites mais altos. A OpenAI analisa cada solicitação individualmente.

Se a API retornar 429 rate_limit_exceeded, reduza a frequência das requisições e respeite o tempo de espera indicado no cabeçalho Retry-After, quando presente. Consulte a documentação sobre limites de taxa para obter orientações gerais sobre novas tentativas.

Como usar os resultados da verificação de forma responsável

Use os resultados da verificação como evidências em um processo de análise mais amplo:

• Interprete detected como evidência de um sinal compatível específico. Esse resultado não fornece o histórico completo do arquivo.
• Interprete not_detected como indicação de que a ferramenta não encontrou o sinal. Esse resultado não prova que uma pessoa criou o conteúdo nem descarta a possibilidade de ele ter sido gerado com ferramentas da OpenAI.
• Confira o emissor do manifesto C2PA antes de atribuir uma imagem a determinado provedor.
• Sempre que possível, verifique o arquivo original. Compressão, recortes, capturas de tela, remoção de metadados e conversões de formato podem apagar ou enfraquecer um sinal.
• Leve em conta o produto e o modelo de origem, o formato do arquivo e a data de criação. Nem todo conteúdo gerado pela OpenAI contém um sinal compatível.
• Combine decisões automatizadas com revisão humana em fluxos de trabalho nos quais as decisões podem ter consequências graves.
• Não faça consultas repetidas para realizar engenharia reversa de uma marca-d’água, removê-la ou contornar sua detecção.
• Não tente deduzir, a partir do resultado de uma verificação, qual foi o prompt, qual conta foi usada ou quem criou o conteúdo.

O uso da API de proveniência de conteúdo está sujeito ao Contrato de Serviços da OpenAI.

Para obter informações sobre as configurações de monitoramento e retenção em toda a plataforma, consulte os controles de dados.