Proveniência do conteúdo

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

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

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

O que a verificação de proveniência do conteúdo analisa

A verificação de proveniência do conteúdo analisa arquivos compatíveis em busca dos seguintes sinais:

Os metadados C2PA fornecem mais contexto sobre a origem de um arquivo. Editar, converter ou compartilhar um arquivo pode remover seus metadados. Uma marca-d'água SynthID faz parte da própria imagem ou do próprio áudio e pode resistir a algumas transformações.

A API verifica a presença de sinais da OpenAI compatíveis. 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 verificados pela API.

Verifique um arquivo

Envie um arquivo de imagem ou áudio no campo file usando o OpenAI SDK. O SDK monta a requisição multipart e lê sua 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
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 estas versões do OpenAI SDK ou posteriores: Python 2.52.0, Go 3.49.0 e Ruby 0.75.0.

Para verificar á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 completo. Por exemplo, a verificação de uma imagem retorna:

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 é o horário de criação da verificação, expresso como um timestamp Unix em segundos. As entradas em results dependem do arquivo enviado: imagens incluem resultados C2PA e SynthID, e áudio inclui um resultado SynthID. A API omite as verificações que não se aplicam em vez de retornar not_detected.

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

Se uma requisição falhar, verifique o status HTTP e error.code, quando disponível. Um arquivo malformado, incompatível ou bloqueado retorna 400; uma organização sem acesso recebe 404; e requisições que excedem o limite de taxa retornam 429. Tente novamente apenas em caso de falhas transitórias, como limites de taxa ou erros de servidor. Para orientações gerais, consulte Códigos de erro da API.

Entenda os resultados da verificação

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

Resultados C2PA

Um resultado 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"
}

Use os campos da seguinte forma:

• outcome indica se as credenciais de geração por IA emitidas pela OpenAI foram detected ou not_detected.
• validation_state indica se o manifesto está no estado 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 identifica o horário de geração do conteúdo quando essa informação está disponível.

O resultado é detected somente quando um manifesto no estado trusted ou valid identifica a OpenAI como emissora e inclui uma ação de geração por IA. Um manifesto de terceiros, um manifesto sem ação de geração por IA, um manifesto no estado invalid ou um manifesto no estado not_present produz not_detected. Os campos issuer e validation_state ainda podem descrever um manifesto mesmo quando o resultado é not_detected.

Não trate um manifesto no estado invalid como evidência confiável de proveniência. Um resultado not_present significa que a imagem não tem um manifesto C2PA disponível.

Resultados SynthID

Um resultado SynthID indica se o verificador detectou uma marca-d'água compatível em um arquivo de imagem ou áudio:

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

Um resultado detected significa que o arquivo contém uma marca-d'água reconhecida. Um resultado not_detected significa 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 fornecem o modelo que gerou o conteúdo e o horário de geração, quando disponíveis; qualquer um dos campos pode ser null.

Formatos compatíveis e disponibilidade

A API oferece suporte aos seguintes formatos de arquivo:

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

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

Defina o tipo de mídia da parte file enviada. Por exemplo, use image/png para uma imagem PNG ou audio/ogg para áudio Opus. Não adicione um campo type separado nem defina manualmente o cabeçalho multipart/form-data da requisição. A opção -F do curl define o tipo de conteúdo da requisição e o delimitador multipart. Envie um arquivo por requisição.

As verificações de proveniência do conteúdo não são elegíveis para zero retenção de dados.

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

Se a API retornar 429 rate_limit_exceeded, reduza a taxa de requisições e respeite o cabeçalho Retry-After, quando presente. Consulte limites de taxa para orientações gerais sobre novas tentativas.

Use os resultados da verificação com responsabilidade

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

• Trate detected como evidência de um sinal compatível específico, não como um histórico completo de um arquivo.
• Trate not_detected como ausência de evidências detectadas, não como prova de que o conteúdo foi criado por uma pessoa ou não foi gerado com a OpenAI.
• Verifique o emissor C2PA antes de atribuir uma imagem a um provedor específico.
• Verifique o arquivo original sempre que possível. 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 de origem, o modelo, 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 de alto impacto.
• Não use consultas repetidas para fazer engenharia reversa de uma marca-d'água, removê-la ou contorná-la.
• Não deduza o prompt, a conta ou a identidade de quem criou o conteúdo a partir de um resultado de verificação.

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

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