Procedencia del contenido

Usa la API de procedencia del contenido para comprobar si una imagen o un archivo de audio contiene alguna de las señales de procedencia de OpenAI que admite la API. Envía un archivo a POST /v1/content_provenance_checks para recibir los resultados de la verificación en la misma respuesta. Usa estas señales en procesos de revisión de contenido, verificación de datos, etiquetado y gestión de confianza y seguridad.

Para verificar un archivo en tu navegador, usa la herramienta web en openai.com/verify.

Para consultar los parámetros de solicitud y los esquemas de respuesta, ve a la referencia de la API de procedencia del contenido.

Para verificar texto, solicita acceso. Por ahora, la verificación de texto solo está disponible para organizaciones aprobadas, entre ellas instituciones de investigación en IA e instituciones académicas. OpenAI evalúa cada solicitud de forma individual.

Qué señales de procedencia verifica la API

La API busca las siguientes señales en los archivos compatibles:

Los metadatos C2PA aportan más contexto sobre el origen de un archivo. Al editar, convertir o compartir el archivo, se pueden perder sus metadatos. La marca de agua SynthID forma parte de la propia imagen o del audio y puede conservarse tras algunas transformaciones.

La API busca las señales de OpenAI que admite. No es un detector de IA de uso general y no identifica el contenido generado por todos los sistemas de IA. Las marcas de agua visibles y las etiquetas son distintas de las señales de procedencia que verifica la API.

Verificar un archivo

Usa el SDK de OpenAI para enviar una imagen o un archivo de audio en el campo file. El SDK construye la solicitud multiparte y lee tu clave de API de la variable de entorno 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"

Usa estas versiones del SDK de OpenAI o versiones posteriores: Python 2.52.0, Go 3.49.0 y Ruby 0.75.0.

Para verificar audio en formato Opus, usa el mismo punto de acceso y establece el tipo de medio del archivo que subas en audio/ogg:

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

La respuesta contiene el resultado final. Por ejemplo, al verificar una imagen, puedes recibir esta respuesta:

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
    }
  ]
}

El campo object identifica la respuesta y created_at indica cuándo se creó la verificación mediante una marca de tiempo Unix en segundos. Las entradas de results dependen del archivo que subas: para imágenes se incluyen resultados de C2PA y SynthID, y para audio se incluye un resultado de SynthID. La API omite las verificaciones que no corresponden en lugar de devolver not_detected.

La API completa la verificación antes de responder. No necesitas crear una tarea en segundo plano, consultar repetidamente otro punto de acceso ni subir el archivo a la API de archivos.

Si una solicitud falla, revisa el código de estado HTTP y, si está disponible, error.code. Si el archivo tiene un formato incorrecto, no es compatible o está bloqueado, la API devuelve 400. Si la organización no tiene acceso, recibe 404. Si superas el límite de solicitudes, la API devuelve 429. Reintenta la solicitud solo ante fallas transitorias, por ejemplo, si alcanzas el límite de solicitudes o si se produce un error del servidor. Para obtener orientación general, consulta los códigos de error de la API.

Interpretar los resultados de la verificación

Interpreta por separado cada entrada de results que corresponda al archivo. Los resultados de imágenes incluyen entradas de C2PA y SynthID, mientras que los de audio incluyen una entrada de SynthID. La respuesta no incluye un campo outcome en el nivel superior.

Resultados de C2PA

El resultado de C2PA describe el estado de las credenciales de contenido de una imagen:

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

Interpreta los campos de la siguiente manera:

• outcome indica si se detectaron credenciales de generación con IA emitidas por OpenAI (detected) o si no se detectaron (not_detected).
• validation_state indica si el estado del archivo de manifiesto es trusted, valid, invalid o not_present.
• issuer identifica al emisor del archivo de manifiesto cuando esa información está disponible.
• model identifica el modelo que generó el contenido cuando esa información está disponible.
• generated_at indica cuándo se generó el contenido si esa información está disponible.

El resultado es detected solo cuando un archivo de manifiesto con estado trusted o valid identifica a OpenAI como emisor e incluye una acción de generación con IA. Si el archivo de manifiesto es de un tercero, no incluye una acción de generación con IA, tiene el estado invalid o figura como not_present, el resultado es not_detected. Los campos issuer y validation_state pueden describir el archivo de manifiesto incluso cuando el resultado es not_detected.

No consideres un archivo de manifiesto con estado invalid como evidencia confiable de procedencia. Un resultado not_present significa que la imagen no tiene ningún archivo de manifiesto C2PA disponible.

Resultados de SynthID

El resultado de SynthID indica si el verificador detectó una marca de agua compatible en una imagen o un archivo de audio:

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

Un resultado detected significa que el archivo contiene una marca de agua reconocida. Un resultado not_detected significa que el verificador no detectó esa marca de agua. Esto no descarta que el contenido se haya generado o modificado con IA. Los campos model y generated_at indican qué modelo generó el contenido y cuándo lo generó, respectivamente, si esa información está disponible. Cualquiera de los dos campos puede tener el valor null.

Archivos admitidos

De forma predeterminada, la API admite los siguientes formatos de archivo:

• Imágenes: PNG, JPEG, WebP y GIF.
• Audio: MP3, Opus, AAC, FLAC, WAV y PCM.

Cada archivo que subas debe tener un tamaño máximo de 50 MiB. Una vez decodificado, el audio debe durar 60 segundos o menos.

Especifica el tipo de medio de la parte file de la solicitud. Usa image/gif para un GIF, image/png para una imagen PNG o audio/ogg para audio en formato Opus. No agregues un campo type separado ni configures manualmente el encabezado de la solicitud como multipart/form-data. En curl, la opción -F establece el tipo de contenido de la solicitud y el delimitador que separa sus partes. Envía un archivo por solicitud.

Límites de solicitudes

Los límites estrictos de solicitudes ayudan a proteger la API contra el uso indebido. Las organizaciones pueden solicitar límites más altos. OpenAI evalúa cada solicitud de forma individual.

Si la API devuelve 429 rate_limit_exceeded, envía solicitudes con menor frecuencia y respeta el encabezado Retry-After cuando esté presente. Consulta la guía sobre límites de solicitudes para obtener orientación general sobre los reintentos.

Usar los resultados de la verificación de manera responsable

Usa los resultados de la verificación como evidencia dentro de un proceso de revisión más amplio:

• Interpreta detected como evidencia de una señal específica admitida. El resultado no proporciona el historial completo del archivo.
• Interpreta not_detected como indicación de que no se detectó evidencia. No demuestra que una persona haya creado el contenido ni que se haya generado sin OpenAI.
• Comprueba quién emitió las credenciales C2PA antes de atribuir una imagen a un proveedor en particular.
• Verifica el archivo original siempre que sea posible. La compresión, los recortes, las capturas de pantalla, la eliminación de metadatos y las conversiones de formato pueden borrar o debilitar una señal.
• Ten en cuenta el producto y el modelo de origen, el formato del archivo y la fecha de creación. No todo el contenido generado por OpenAI contiene una señal admitida.
• Complementa las decisiones automatizadas con una revisión humana en los procesos en los que una decisión pueda tener consecuencias importantes.
• No hagas consultas repetidas para aplicar ingeniería inversa a una marca de agua, eliminarla o eludirla.
• No intentes deducir a partir del resultado de una verificación qué prompt o cuenta se usó ni qué persona creó el contenido.

El uso de la API de procedencia del contenido está sujeto al Acuerdo de servicios de OpenAI.

Para obtener información sobre la configuración de monitoreo y retención en toda la plataforma, consulta los controles de datos.