Provenance des contenus

Utilisez l’API Content Provenance pour vérifier si une image ou un fichier audio contient des signaux de provenance d’OpenAI que l’API prend en charge. Envoyez un fichier à POST /v1/content_provenance_checks pour obtenir les résultats de la vérification dans la même réponse. Utilisez ces signaux dans vos workflows d’examen et d’étiquetage des contenus, de vérification des faits, ainsi que de confiance et de sécurité.

Pour vérifier un fichier dans votre navigateur, utilisez l’outil en ligne sur openai.com/verify.

Pour connaître les paramètres de requête et les schémas de réponse, consultez la référence de l’API Content Provenance.

Pour vérifier du texte, demandez l’accès. La vérification de texte est actuellement réservée aux organisations approuvées, parmi lesquelles figurent des organismes de recherche en IA et des établissements universitaires. OpenAI examine chaque demande au cas par cas.

Signaux de provenance vérifiés

L’API recherche les signaux suivants dans les fichiers pris en charge :

Les métadonnées C2PA fournissent des précisions sur l’origine d’un fichier. La modification, la conversion ou le partage d’un fichier peuvent supprimer ses métadonnées. Un filigrane SynthID fait partie intégrante de l’image ou du signal audio et peut subsister après certaines transformations.

L’API recherche les signaux d’OpenAI qu’elle prend en charge. Ce n’est pas un détecteur d’IA universel : elle ne permet pas d’identifier les contenus générés par tous les systèmes d’IA. Les filigranes visibles et les mentions de provenance sont distincts des signaux que vérifie l’API.

Vérifier un fichier

Avec le SDK OpenAI, envoyez une image ou un fichier audio dans le champ file. Le SDK construit la requête multipart et lit votre clé API dans la variable d’environnement 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"

Utilisez au minimum les versions suivantes des SDK OpenAI : 2.52.0 pour Python, 3.49.0 pour Go et 0.75.0 pour Ruby.

Pour vérifier un fichier audio Opus, utilisez le même point de terminaison et indiquez audio/ogg comme type de média du fichier envoyé :

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

La réponse contient le résultat final de la vérification. Voici un exemple de réponse pour une image :

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

Le champ object identifie le type de réponse. Le champ created_at indique la date de création de la vérification sous forme d’horodatage Unix en secondes. Les entrées de results dépendent du fichier envoyé : pour une image, l’API renvoie les résultats C2PA et SynthID ; pour un fichier audio, elle renvoie le résultat SynthID. L’API omet les vérifications qui ne s’appliquent pas au fichier au lieu de renvoyer not_detected.

L’API termine la vérification avant de répondre. Vous n’avez pas besoin de créer une tâche en arrière-plan, d’interroger périodiquement un autre point de terminaison ni d’envoyer le fichier à l’API Files.

Si une requête échoue, vérifiez le code d’état HTTP et le champ error.code s’il est disponible. Un fichier mal formé, non pris en charge ou bloqué entraîne une réponse 400. Une organisation sans accès reçoit une réponse 404. Les requêtes qui dépassent la limite de débit entraînent une réponse 429. Ne réessayez qu’en cas d’échec temporaire, par exemple si vous atteignez une limite de débit ou si une erreur de serveur survient. Pour en savoir plus, consultez les codes d’erreur de l’API.

Interpréter les résultats de vérification

Examinez séparément chaque entrée applicable de results. Les résultats d’une image comportent une entrée C2PA et une entrée SynthID. Ceux d’un fichier audio comportent une entrée SynthID. La réponse ne contient pas de champ outcome à la racine.

Résultats C2PA

Un résultat C2PA indique l’état des Content Credentials d’une image :

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

Interprétez les champs comme suit :

• outcome indique si la vérification a détecté des attestations émises par OpenAI signalant une génération par IA (detected ou not_detected).
• validation_state indique l’état du manifeste : trusted, valid, invalid ou not_present.
• issuer indique qui a émis le manifeste, si cette information est disponible.
• model indique quel modèle a généré le contenu, si cette information est disponible.
• generated_at indique quand le contenu a été généré, si cette information est disponible.

Le résultat est detected uniquement si un manifeste dont l’état est trusted ou valid indique qu’OpenAI en est l’émetteur et contient une action de génération par IA. Si le manifeste provient d’un tiers, ne contient aucune action de génération par IA ou présente l’état invalid ou not_present, le résultat est not_detected. Les champs issuer et validation_state peuvent fournir des informations sur le manifeste même si le résultat est not_detected.

Ne considérez pas un manifeste dont l’état est invalid comme une preuve fiable de provenance. Le résultat not_present signifie qu’aucun manifeste C2PA n’est disponible pour l’image.

Résultats SynthID

Un résultat SynthID indique si l’outil de vérification a détecté un filigrane pris en charge dans une image ou un fichier audio :

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

Le résultat detected signifie que le fichier contient un filigrane reconnu. Le résultat not_detected signifie que l’outil de vérification n’a pas détecté ce filigrane. Il reste possible qu’une IA ait généré ou modifié le contenu. Les champs model et generated_at indiquent respectivement le modèle utilisé et la date de génération lorsque ces informations sont disponibles. Chacun de ces champs peut avoir la valeur null.

Fichiers pris en charge

Par défaut, l’API prend en charge les formats de fichiers suivants :

• Images : PNG, JPEG, WebP et GIF.
• Audio : MP3, Opus, AAC, FLAC, WAV et PCM.

Limitez la taille de chaque fichier envoyé à 50 Mio. Après décodage, la durée de l’audio ne doit pas dépasser 60 secondes.

Indiquez le type de média de la partie file de la requête. Utilisez image/gif pour un fichier GIF, image/png pour une image PNG ou audio/ogg pour un fichier audio Opus. N’ajoutez pas de champ type distinct et ne définissez pas manuellement l’en-tête de requête multipart/form-data. Avec curl, l’option -F définit le type de contenu de la requête et le délimiteur multipart. Envoyez un seul fichier par requête.

Limites de débit

Des limites de débit strictes contribuent à protéger l’API contre les abus. Les organisations peuvent demander un relèvement de leurs limites de débit. OpenAI examine chaque demande au cas par cas.

Si l’API renvoie 429 rate_limit_exceeded, réduisez la fréquence de vos requêtes et respectez le délai indiqué dans l’en-tête Retry-After s’il est présent. Pour des conseils généraux sur les nouvelles tentatives, consultez le guide sur les limites de débit.

Utiliser les résultats de vérification de manière responsable

Intégrez les résultats de vérification aux autres éléments pris en compte lors de l’examen d’un contenu :

• Un résultat detected atteste la présence d’un signal précis pris en charge par l’API. Il ne retrace pas l’historique complet du fichier.
• Un résultat not_detected indique qu’aucun signal n’a été détecté. Il ne prouve ni qu’une personne a créé le contenu ni que le contenu a été généré sans OpenAI.
• Vérifiez l’émetteur du manifeste C2PA avant d’attribuer une image à un fournisseur donné.
• Dans la mesure du possible, vérifiez le fichier d’origine. La compression, le recadrage, les captures d’écran, la suppression des métadonnées et les conversions de format peuvent effacer ou affaiblir un signal.
• Tenez compte du produit et du modèle à l’origine du contenu, du format du fichier et de sa date de création. Les contenus générés par OpenAI ne contiennent pas tous un signal pris en charge.
• Prévoyez un examen humain des décisions automatisées dans les workflows à forts enjeux.
• N’utilisez pas de requêtes répétées pour analyser un filigrane par rétro-ingénierie, le supprimer ou contourner sa détection.
• Ne tentez pas de déduire d’un résultat de vérification le prompt utilisé, le compte d’origine ou l’identité de la personne qui a créé le contenu.

L’utilisation de l’API Content Provenance est soumise au contrat de services d’OpenAI.

Pour connaître les paramètres de surveillance et de conservation des données à l’échelle de la plateforme, consultez le guide sur le contrôle des données.