DEV Community

Cover image for Comment vérifier si une image est générée par IA (Guide 2026)
Antoine Laurent
Antoine Laurent

Posted on • Originally published at apidog.com

Comment vérifier si une image est générée par IA (Guide 2026)

OpenAI a publié l’article « Faire progresser la provenance du contenu pour un écosystème d'IA plus sûr et plus transparent ». L’annonce confirme plusieurs évolutions importantes : OpenAI rejoint le comité de pilotage C2PA, ajoute le filigrane SynthID de Google à ses images générées, propose un outil public pour vérifier si une image provient d’OpenAI, et ouvre l’accès à un classificateur de détection d’images DALL-E 3 via son programme chercheurs. Pour les développeurs, cela transforme une question générale — « cette image est-elle réelle ? » — en workflow produit : collecter le fichier, vérifier la provenance, détecter les filigranes, appeler une API de classification, puis retourner un niveau de confiance exploitable.

Essayez Apidog aujourd’hui

💡 Si vous développez une application, “vérifier une image” signifie souvent intégrer une API de détection, tester ses réponses sur des fichiers réels, gérer les cas non concluants et journaliser les résultats. C’est typiquement le genre d’intégration que vous pouvez concevoir, tester et rejouer dans Apidog avant de la déployer.

En bref

Pour vérifier si une image est générée par l’IA, utilisez une pile de méthodes plutôt qu’un seul outil :

  1. Vérifiez les C2PA Content Credentials : c’est le signal le plus fort si les métadonnées sont présentes.
  2. Cherchez un filigrane invisible comme Google SynthID.
  3. Appelez un classificateur ML ou une API de détection pour obtenir un score probabiliste.
  4. Inspectez visuellement l’image pour repérer les erreurs évidentes.
  5. Lancez une recherche d’image inversée pour retrouver son historique en ligne.
  6. Retournez un niveau de confiance, pas un verdict absolu.

Le workflow minimal :

fichier original
  -> vérification C2PA
  -> détection SynthID
  -> score API / classificateur
  -> inspection visuelle
  -> recherche inversée
  -> décision pondérée : IA probable / réel probable / indéterminé
Enter fullscreen mode Exit fullscreen mode

Aucune méthode n’est concluante seule. Les métadonnées de provenance sont fiables lorsqu’elles existent, mais elles peuvent être supprimées. Les filigranes sont utiles, mais seulement pour les modèles qui les appliquent. Les classificateurs couvrent plus de cas, mais produisent des faux positifs.

Pourquoi vous avez besoin de plusieurs méthodes

Il y a deux ans, beaucoup d’images générées par IA étaient faciles à repérer : mains incorrectes, texte illisible, lunettes fusionnées avec le visage, arrière-plans incohérents. Ce n’est plus vrai pour les modèles récents. Les générateurs actuels produisent des images qui passent souvent une inspection humaine rapide, et parfois même une inspection experte.

Deux approches sont donc devenues centrales :

  • La provenance : attacher au fichier un historique signé de sa création et de ses modifications.
  • Le filigrane invisible : intégrer un signal statistique directement dans les pixels.

Ces deux méthodes sont proactives, mais elles dépendent de la coopération du générateur ou de la plateforme. Elles peuvent aussi être supprimées ou dégradées.

C’est pourquoi une approche robuste combine plusieurs signaux :

  • C2PA : fiable, mais souvent absent.
  • SynthID : fort si positif, mais spécifique à certains modèles.
  • Classificateurs ML : applicables à beaucoup d’images, mais probabilistes.
  • Inspection visuelle : utile pour les erreurs évidentes, faible sur les bons modèles.
  • Recherche inversée : utile pour le contexte, pas pour les images inédites.

Méthode 1 : vérifier les C2PA Content Credentials

C2PA signifie Coalition for Content Provenance and Authenticity. C’est une norme ouverte qui attache à un fichier média un manifeste cryptographiquement signé. Le nom utilisateur est Content Credentials.

Un manifeste peut indiquer :

  • quel outil a créé le fichier ;
  • quand il a été créé ;
  • s’il a été modifié ;
  • si l’IA a été impliquée ;
  • si la signature est toujours valide.

OpenAI joint des C2PA Content Credentials aux images DALL-E 3 depuis 2024. Son annonce de mai 2026 confirme également une conformité C2PA plus large, ce qui permet à d’autres plateformes de lire, préserver et transmettre ces données.

Étapes pratiques

  1. Récupérez le fichier original. Évitez les captures d’écran et les images réenregistrées.
  2. Ouvrez un inspecteur de Content Credentials, par exemple contentcredentials.org.
  3. Glissez-déposez l’image dans l’outil.
  4. Lisez le résultat :
    • manifeste valide ;
    • aucune donnée Content Credentials ;
    • manifeste invalide ou altéré.

Un manifeste valide peut fournir une preuve forte de l’origine du fichier. Par exemple :

Résultat C2PA :
- Producteur : outil IA compatible C2PA
- Action : image générée
- Signature : valide
- Historique : intact
Enter fullscreen mode Exit fullscreen mode

Dans ce cas, vous pouvez conclure que l’image est générée par IA avec un niveau de confiance élevé.

Limites

Le C2PA est fragile dans la pratique. Les métadonnées peuvent disparaître lors de :

  • captures d’écran ;
  • conversions de format ;
  • réencodages ;
  • téléchargements sur certaines plateformes sociales ;
  • suppressions volontaires.

Autre point important : C2PA vérifie l’intégrité du manifeste, pas la vérité de la scène représentée. Une photo mise en scène ou trompeuse peut avoir une signature valide.

À retenir :

C2PA valide + mention IA = preuve forte
C2PA absent = aucune conclusion
C2PA invalide = fichier modifié ou manifeste cassé
Enter fullscreen mode Exit fullscreen mode

Méthode 2 : détecter les filigranes invisibles comme SynthID

Un filigrane invisible est un signal intégré directement dans les pixels. SynthID, développé par Google DeepMind, ajoute ce type de signal aux images générées par certains modèles Google, notamment Gemini et Imagen.

Depuis l’annonce de mai 2026, OpenAI ajoute aussi SynthID à ses images générées. Cela permet à un même détecteur de couvrir le contenu issu de plusieurs fournisseurs majeurs.

Étapes pratiques

  1. Ouvrez le portail public SynthID Detector de Google.
  2. Téléchargez l’image.
  3. Vérifiez si un filigrane SynthID est détecté.
  4. Notez le résultat dans votre décision finale.

Vous pouvez consulter la documentation générale sur la page SynthID de Google DeepMind.

Interprétation

Un résultat positif est un signal fort :

SynthID détecté -> image IA très probable
Enter fullscreen mode Exit fullscreen mode

Un résultat négatif ne prouve presque rien :

SynthID non détecté -> image peut être réelle, IA sans SynthID, modifiée ou issue d’un autre modèle
Enter fullscreen mode Exit fullscreen mode

Limites

SynthID est utile, mais pas universel :

  • il ne couvre pas tous les générateurs ;
  • les modèles open source peuvent être exécutés sans filigrane ;
  • les modifications lourdes peuvent affaiblir le signal ;
  • un résultat négatif ne signifie pas “image réelle”.

Méthode 3 : utiliser un classificateur ML ou une API de détection

Quand il n’y a ni C2PA ni filigrane détectable, utilisez un classificateur de détection. Ces modèles sont entraînés sur des images réelles et synthétiques pour repérer des empreintes statistiques : bruit de capteur absent, artefacts fréquentiels, motifs de texture, compression atypique, etc.

La sortie typique ressemble à ceci :

{
  "ai_probability": 0.87,
  "label": "likely_ai_generated",
  "model_confidence": "high"
}
Enter fullscreen mode Exit fullscreen mode

Ce score doit être traité comme une probabilité, pas comme une preuve.

Intégration côté développeur

Pour intégrer ce type de détection dans une application :

  1. Créez un endpoint interne, par exemple : 
POST /api/image-verification
Content-Type: multipart/form-data
Enter fullscreen mode Exit fullscreen mode
  1. Envoyez l’image au fournisseur de détection.
  2. Normalisez la réponse.
  3. Ajoutez vos propres règles métier.
  4. Retournez un résultat exploitable par le produit.

Exemple de réponse interne :

{
  "status": "review_required",
  "signals": {
    "c2pa": "not_found",
    "synthid": "not_detected",
    "ml_score": 0.82,
    "reverse_search": "no_match"
  },
  "verdict": "ai_possible",
  "confidence": "medium"
}
Enter fullscreen mode Exit fullscreen mode

Si vous comparez des fournisseurs, ce récapitulatif des meilleures API de détection d'images IA pour les développeurs couvre les critères utiles. Si vous préférez construire votre propre pipeline, ce guide explique comment créer votre propre API de détection d'images IA.

Pour tester l’intégration, vous pouvez créer et rejouer vos requêtes dans Apidog, avec des environnements séparés pour le développement, la préproduction et la production. Si votre logique de détection est utilisée par un agent IA, le débogueur d'agent IA d'Apidog permet de tracer ce que le modèle envoie et reçoit.

Exemple de pseudo-code 

async function verifyImage(file) {
  const result = {
    c2pa: null,
    synthid: null,
    classifier: null,
    verdict: "indeterminate",
    confidence: "low"
  };

  result.c2pa = await checkC2PA(file);

  if (result.c2pa?.aiGenerated === true && result.c2pa?.valid === true) {
    return {
      ...result,
      verdict: "ai_generated",
      confidence: "high"
    };
  }

  result.synthid = await checkSynthID(file);

  if (result.synthid?.detected === true) {
    return {
      ...result,
      verdict: "ai_generated",
      confidence: "high"
    };
  }

  result.classifier = await callImageDetectionApi(file);

  if (result.classifier.aiProbability >= 0.9) {
    return {
      ...result,
      verdict: "ai_likely",
      confidence: "medium"
    };
  }

  if (result.classifier.aiProbability <= 0.1) {
    return {
      ...result,
      verdict: "real_likely",
      confidence: "medium"
    };
  }

  return result;
}
Enter fullscreen mode Exit fullscreen mode

Limites

Les classificateurs sont pratiques, mais incertains :

  • Faux positifs : une vraie photo fortement éditée peut être signalée comme IA.
  • Nouveaux modèles : un détecteur peut être moins précis sur un générateur récent.
  • Modifications adverses : bruit, compression ou filtres peuvent perturber le score.
  • Zone grise : un score de 60 % ou 70 % ne doit pas être traité comme une preuve.

Pour approfondir ces limites, consultez l’article sur les raisons pour lesquelles la détection d'images IA échoue.

Méthode 4 : inspection visuelle manuelle

L’inspection visuelle reste utile, mais seulement comme signal complémentaire. Elle fonctionne surtout sur les images générées par des modèles plus anciens, des prompts mal contrôlés ou des sorties non sélectionnées.

Vérifiez notamment :

  • Mains et doigts : doigts fusionnés, phalanges étranges, posture impossible.
  • Texte : enseignes, logos, livres, affiches ou vêtements illisibles.
  • Dents et bijoux : dents trop nombreuses, boucles d’oreilles asymétriques, colliers incohérents.
  • Accessoires : lunettes, montres, bracelets ou ceintures qui disparaissent ou se déforment.
  • Reflets et ombres : miroirs, lunettes de soleil, eau ou ombres incohérentes.
  • Éclairage : sources lumineuses contradictoires.
  • Arrière-plan : objets fusionnés, textures répétitives, architecture impossible.
  • Peau et texture : rendu trop lisse, pores absents, aspect plastifié.

Règle d’interprétation 

Erreur visuelle évidente -> signal fort d’IA
Aucune erreur visible -> aucune conclusion
Enter fullscreen mode Exit fullscreen mode

Les modèles récents produisent souvent des mains correctes, du texte lisible et un éclairage cohérent. Une image impeccable peut être réelle ou générée. L’inspection visuelle ne suffit donc jamais à déclarer une image authentique.

Méthode 5 : recherche d’image inversée

La recherche d’image inversée ne détecte pas directement l’IA. Elle permet de retrouver l’historique d’une image en ligne.

Utilisez Google Images, TinEye ou un outil similaire.

Cherchez :

  • Une source claire : banque d’images, photographe, média, archive.
  • Une origine IA : galerie Midjourney, communauté d’art IA, site de prompts.
  • Un profil suspect : visage utilisé sur plusieurs comptes sans lien.
  • Une incohérence de contexte : image ancienne présentée comme événement récent.

Exemples d’interprétation :

Image trouvée dans une archive de 2018 -> probablement non générée par IA récente
Image trouvée sur une galerie “made with Midjourney” -> origine IA probable
Aucune correspondance -> indéterminé
Enter fullscreen mode Exit fullscreen mode

Cette méthode est très utile pour les images qui ont circulé, mais inutile pour une image fraîchement générée et jamais publiée.

Comparaison des méthodes

Méthode Fiabilité Ce qu'elle détecte Ce qu'elle manque Effort / coût
C2PA Content Credentials La plus élevée, si présente Origine, historique d'édition, implication de l'IA, signé et vérifiable Tout ce qui est capturé, ré-encodé ou dont les métadonnées sont supprimées Faible ; outils de navigateur gratuits
Filigrane invisible (SynthID) Élevée, si présente Images IA des modèles de filigrane (Google, et maintenant OpenAI) Modèles sans filigrane, générateurs open-source, fichiers fortement dégradés Faible ; portail gratuit
Classificateur de détection ML / API Modérée ; probabiliste Empreintes statistiques d'IA sur toute image, pas de métadonnées nécessaires Nouveaux modèles, modifications adverses ; produit de faux positifs Faible à moyen ; outils gratuits ou API payante
Inspection visuelle manuelle Faible sur les modèles de pointe Erreurs évidentes sur les sorties plus faibles ou non sélectionnées Tout ce qui provient d'un modèle de pointe actuel ou d'un faux préparé Faible ; gratuit, mais nécessite un œil averti
Recherche d'image inversée Modérée ; indirecte Historique de l'image, source originale, images réutilisées ou mal représentées Images fraîchement générées jamais publiées auparavant Faible ; gratuit

Résumé opérationnel :

Méthodes 1-2 : très fortes si positives, souvent absentes
Méthodes 3-5 : plus disponibles, mais jamais définitives seules
Enter fullscreen mode Exit fullscreen mode

Construire un verdict exploitable

Dans une application, évitez un booléen simple comme :

{
  "is_ai": true
}
Enter fullscreen mode Exit fullscreen mode

Préférez une réponse structurée :

{
  "verdict": "ai_likely",
  "confidence": "high",
  "signals": {
    "c2pa": {
      "status": "valid",
      "ai_generated": true
    },
    "synthid": {
      "detected": false
    },
    "classifier": {
      "score": 0.94
    },
    "manual_review": {
      "required": false
    }
  }
}
Enter fullscreen mode Exit fullscreen mode

Un flux de décision simple :

  1. Fichier original disponible ?

    Vérifiez C2PA. Si un manifeste IA valide existe, retournez ai_generated avec confiance élevée.

  2. SynthID détecté ?

    Retournez ai_generated avec confiance élevée.

  3. Score classificateur très élevé ?

    Si le score dépasse environ 90 %, retournez ai_likely, mais gardez la mention probabiliste.

  4. Score intermédiaire ?

    Retournez review_required ou indeterminate.

  5. Recherche inversée cohérente ?

    Ajoutez le contexte au résultat final.

  6. Signaux contradictoires ?

    Retournez indeterminate.

Exemple :

{
  "verdict": "indeterminate",
  "confidence": "low",
  "reason": "Aucune provenance C2PA, aucun filigrane SynthID, score classificateur moyen.",
  "recommended_action": "manual_review"
}
Enter fullscreen mode Exit fullscreen mode

C’est souvent la meilleure réponse produit. Mieux vaut dire “indéterminé” que retourner un faux verdict.

Conclusion

Vérifier si une image est générée par l’IA en 2026 n’est pas un test unique. C’est une combinaison de signaux.

À retenir :

  • Commencez par C2PA, car c’est le signal le plus fiable lorsqu’il existe.
  • Cherchez ensuite SynthID, car un résultat positif est fort.
  • Utilisez les classificateurs ML comme signal probabiliste, jamais comme preuve unique.
  • Gardez l’inspection visuelle pour les erreurs évidentes, pas pour confirmer qu’une image est réelle.
  • Ajoutez la recherche inversée pour comprendre l’historique de l’image.
  • Retournez un niveau de confiance, pas un verdict absolu.
  • Prévoyez un état indeterminate dans vos produits.

Si vous intégrez cette logique dans une application, la prochaine étape consiste à connecter une API de détection, tester des fichiers réels et valider les réponses dans plusieurs environnements. Téléchargez Apidog pour concevoir, déboguer et tester cette intégration dans un espace de travail unique.

Top comments (0)