C2PA ve Sınıflandırıcı ile Yapay Zeka Görsel Dedektörü API'si Oluşturma

Ürününüz için biri fotoğraf yüklüyor ve bunun kamerayla çekildiğini söylüyor. Arka ucunuz bunu doğrulayabilir mi? Tek bir “AI mı değil mi?” testi yeterli değildir: görüntü oluşturucular insan gözüne gerçek görünen sonuçlar üretir, meta veriler ise kolayca kaybolabilir. Bu rehberde iki bağımsız sinyali birleştiren bir POST /verify servisi kuracağız: C2PA İçerik Kimlik Bilgileri ile kriptografik provenans ve barındırılan bir AI görüntü sınıflandırıcısı. Servis bir görüntü alacak, güven puanı ve provenans detaylarıyla birlikte JSON karar döndürecek. Python, FastAPI, açık kaynak C2PA araçları ve bir algılama API’si kullanacağız. API sözleşmesini önce tasarlayıp mock ve test akışı için Apidog kullanacağız.

Apidog'u bugün deneyin

TL;DR

POST /verify uç noktasına sahip bir FastAPI servisi oluşturacaksınız. Servis:

1. multipart/form-data ile görüntü yüklemesi alacak.
2. c2pa-python ile C2PA manifestini okuyup doğrulayacak.
3. İkinci sinyal olarak barındırılan bir AI görüntü algılama API’sini çağıracak.
4. Sonuçları tek JSON yanıtta birleştirecek:

{
  "verdict": "likely_ai",
  "confidence": 0.86,
  "signals": {
    "provenance": {},
    "classifier": {}
  }
}

Ayrıca OpenAPI şemasını tasarlayıp Apidog’da mock sunucu ve uç nokta testleri oluşturacaksınız.

Neden tek sinyal yetmez?

Bir dosyada doğrudan “bunu insan yaptı” veya “bunu AI yaptı” diyen tek bir özellik yoktur. Bunun yerine iki farklı sinyal kullanılır.

1. Provenans sinyali: C2PA

C2PA, medya dosyasına kriptografik olarak imzalanmış, kurcalamaya dayanıklı meta veri ekleyen açık bir standarttır. Kullanıcı tarafındaki adı genellikle Content Credentials / İçerik Kimlik Bilgileri olarak geçer.

Bir kamera, editör veya görüntü oluşturucu C2PA manifesti yazarsa şunları öğrenebilirsiniz:

• Görüntüyü hangi araç oluşturdu veya düzenledi?
• Manifest geçerli mi?
• İmza ve hash doğrulaması başarılı mı?
• Dosya, iddia edilen geçmişle tutarlı mı?

Ancak C2PA isteğe bağlıdır. Manifest şu durumlarda kaybolabilir:

• ekran görüntüsü alınırsa,
• mesajlaşma uygulaması görüntüyü yeniden kodlarsa,
• platform yükleme sırasında meta veriyi temizlerse,
• dosya yeniden dışa aktarılırsa.

Bu yüzden manifest yokluğu tek başına “sahte” veya “AI” anlamına gelmez.

2. Sınıflandırıcı sinyali

AI görüntü algılama modelleri piksel düzeyindeki örüntülere bakar. Meta veri gerektirmezler, bu yüzden manifest olmasa da çalışırlar.

Ancak sonuç olasılıksaldır:

• 0.92 skoru “model oldukça emin” demektir.
• “Kesin olarak AI” demek değildir.
• Sıkıştırılmış, kırpılmış veya dağılım dışı görüntülerde yanlış pozitif/negatif olabilir.

Bu nedenle en sağlam yaklaşım:

C2PA neyi kriptografik olarak kanıtlıyor, sınıflandırıcı ne tahmin ediyor ve bu ikisi birlikte ne kadar güven veriyor?

Tek sinyalli yaklaşımların neden yetersiz kaldığını daha ayrıntılı görmek için yapay zeka görüntü algılamasının neden başarısız olduğu yazısına bakabilirsiniz.

Mimari

Servis küçük tutulacak:

                ┌─────────────────────────────┐
   görüntü ──▶   │   FastAPI POST /verify       │
                │                              │
                │   1. yüklemeyi doğrula       │
                │   2. C2PA manifestini oku    │  provenans sinyali
                │   3. sınıflandırıcıyı çağır  │  istatistiksel sinyal
                │   4. sonucu birleştir        │
                └─────────────────────────────┘
                              │
                              ▼
                    JSON karar + güven puanı

Kullanılacak yığın:

• Python 3.10+
• FastAPI
• Uvicorn
• python-multipart
• httpx
• c2pa-python

Kurulum:

pip install fastapi "uvicorn[standard]" python-multipart httpx c2pa-python

C2PA sinyalini okuma

Content Authenticity Initiative, açık kaynak C2PA araçlarını contentauth GitHub organizasyonu altında yayınlar.

İki araçla karşılaşabilirsiniz:

• c2patool: manifest görüntülemek veya eklemek için CLI.
• c2pa-python: c2pa-rs üzerine Python bağlaması. Bu serviste bunu kullanacağız.

Aşağıdaki modül, görüntüden C2PA manifestini okur ve normalize edilmiş bir sonuç döndürür.

# provenance.py
import json
import c2pa


def read_provenance(image_path: str) -> dict:
    """
    Bir görüntüden C2PA manifestini oku ve doğrula.
    Normalleştirilmiş provenans sonucu döndürür.
    """
    try:
        with c2pa.Reader(image_path) as reader:
            manifest_store = json.loads(reader.json())

    except c2pa.C2paError as err:
        if str(err).startswith("ManifestNotFound"):
            return {
                "has_manifest": False,
                "validation": "none",
                "detail": "Bu görüntüde C2PA manifesti bulunmuyor.",
            }

        return {
            "has_manifest": True,
            "validation": "error",
            "detail": f"Manifest ayrıştırılamadı: {err}",
        }

    active_label = manifest_store.get("active_manifest")
    manifests = manifest_store.get("manifests", {})
    active = manifests.get(active_label, {})

    validation = "valid" if not manifest_store.get("validation_status") else "invalid"

    return {
        "has_manifest": True,
        "validation": validation,
        "claim_generator": active.get("claim_generator", "unknown"),
        "signature_issuer": active.get("signature_info", {}).get("issuer", "unknown"),
        "validation_status": manifest_store.get("validation_status", []),
        "detail": "Manifest başarıyla okundu.",
    }

Önemli noktalar:

• ManifestNotFound beklenen bir durumdur. Çoğu görüntüde C2PA manifesti yoktur.
• Manifest yokluğu hata değildir.
• validation_status boşsa manifest doğrulanmıştır.
• validation_status doluysa imza, hash veya sertifika doğrulamasında sorun vardır.
• Geçersiz manifest güçlü bir uyarıdır, ancak tek başına “AI” kanıtı değildir.

Sınıflandırıcı sinyali

İkinci sinyal için barındırılan bir AI görüntü algılama API’si kullanacağız. Bu örnekte Sightengine kullanılıyor. Aynı yapı başka sağlayıcılarla da çalışır; URL, parametre ve skor alanını değiştirmeniz yeterlidir.

Alternatifleri karşılaştırmak isterseniz en iyi AI görüntü algılama API’leri yazısına bakabilirsiniz.

Sightengine endpoint’i:

https://api.sightengine.com/1.0/check.json

Gönderilecek alanlar:

• media: görüntü dosyası
• models: genai
• api_user
• api_secret

Yanıttaki skor:

type.ai_generated

Örnek istemci:

# classifier.py
import httpx

SIGHTENGINE_URL = "https://api.sightengine.com/1.0/check.json"


async def classify_image(
    image_bytes: bytes,
    filename: str,
    api_user: str,
    api_secret: str,
    timeout_seconds: float = 8.0,
) -> dict:
    """
    Görüntüyü barındırılan algılayıcıya gönder.
    AI tarafından üretilmiş olma skorunu döndürür.
    """
    data = {
        "models": "genai",
        "api_user": api_user,
        "api_secret": api_secret,
    }
    files = {"media": (filename, image_bytes)}

    try:
        async with httpx.AsyncClient(timeout=timeout_seconds) as client:
            response = await client.post(SIGHTENGINE_URL, data=data, files=files)
            response.raise_for_status()
            payload = response.json()

    except httpx.TimeoutException:
        return {"available": False, "reason": "classifier_timeout"}

    except httpx.HTTPStatusError as err:
        return {
            "available": False,
            "reason": f"classifier_http_{err.response.status_code}",
        }

    except httpx.HTTPError as err:
        return {"available": False, "reason": f"classifier_error: {err}"}

    if payload.get("status") != "success":
        return {
            "available": False,
            "reason": payload.get("error", {}).get("message", "unknown_error"),
        }

    ai_score = payload.get("type", {}).get("ai_generated")
    if ai_score is None:
        return {"available": False, "reason": "missing_score_in_response"}

    return {
        "available": True,
        "ai_score": float(ai_score),
    }

Bu fonksiyon bilinçli olarak exception fırlatmaz. Sınıflandırıcı timeout olursa servis çökmek yerine available: false döndürür. Karar mantığı bu durumu ele alır.

AI görüntüleri pratikte nasıl kontrol edilir görmek için bir görüntünün AI tarafından oluşturulup oluşturulmadığını nasıl kontrol edeceğimiz rehberine bakabilirsiniz.

/verify sözleşmesini tasarlama

Rota işleyicisini yazmadan önce API sözleşmesini tasarlayın. Burada Apidog kullanacağız.

Spec-first yaklaşım size şunları sağlar:

1. Ön uç ve arka uç için ortak sözleşme.
2. Arka uç bitmeden kullanılabilir mock sunucu.
3. Gerçek servis hazır olduğunda çalıştırılacak test senaryoları.

İstek

POST /verify, tek alanlı multipart/form-data alır:

Alan	Tip	Açıklama
image	file	Kontrol edilecek görüntü

Yanıt

Örnek yanıt:

{
  "verdict": "likely_ai",
  "confidence": 0.86,
  "signals": {
    "provenance": {
      "has_manifest": true,
      "validation": "valid",
      "claim_generator": "SomeImageTool/2.1",
      "signature_issuer": "Some Issuing CA"
    },
    "classifier": {
      "available": true,
      "ai_score": 0.91
    }
  },
  "explanation": "Geçerli bir C2PA manifesti bir AI görüntü aracını adlandırıyor ve sınıflandırıcı görüntüyü muhtemelen AI tarafından üretilmiş olarak puanladı.",
  "checked_at": "2026-05-21T09:30:00Z"
}

verdict üç değerden biridir:

• likely_authentic
• likely_ai
• uncertain

İki değer yerine üç değer kullanmak önemlidir. Sinyaller zayıfsa veya çelişiyorsa doğru yanıt “belirsiz” olmalıdır.

OpenAPI bileşeni:

components:
  schemas:
    VerifyResponse:
      type: object
      required: [verdict, confidence, signals, checked_at]
      properties:
        verdict:
          type: string
          enum: [likely_authentic, likely_ai, uncertain]
        confidence:
          type: number
          format: float
          minimum: 0
          maximum: 1
        signals:
          type: object
          properties:
            provenance:
              type: object
              properties:
                has_manifest:
                  type: boolean
                validation:
                  type: string
                  enum: [valid, invalid, error, none]
                claim_generator:
                  type: string
                signature_issuer:
                  type: string
            classifier:
              type: object
              properties:
                available:
                  type: boolean
                ai_score:
                  type: number
                  format: float
        explanation:
          type: string
        checked_at:
          type: string
          format: date-time

Bu şemayı Apidog’un görsel tasarımcısında oluşturabilir veya OpenAPI dosyası olarak içe aktarabilirsiniz. Spec-first akışı için spesifikasyon öncelikli mod eğitimine bakabilirsiniz.

Karar mantığı

Karar fonksiyonu iki sinyali tek sonuca indirger.

Kural seti:

1. Geçerli C2PA manifesti varsa güçlü sinyaldir.
2. Manifest AI aracını adlandırıyorsa likely_ai.
3. Manifest AI olmayan araçtan geliyorsa likely_authentic.
4. Manifest geçersizse uncertain.
5. Manifest yoksa sınıflandırıcı skoruna bakılır.
6. Her iki sinyal de yoksa uncertain.

# verdict.py

def combine_signals(provenance: dict, classifier: dict) -> dict:
    """Provenans ve sınıflandırıcı sinyallerini tek kararda birleştirir."""
    has_manifest = provenance.get("has_manifest", False)
    validation = provenance.get("validation", "none")
    generator = (provenance.get("claim_generator") or "").lower()

    classifier_ok = classifier.get("available", False)
    ai_score = classifier.get("ai_score")

    ai_keywords = (
        "firefly",
        "dall-e",
        "dalle",
        "midjourney",
        "stable",
        "gpt",
        "gemini",
        "imagen",
        "generat",
    )

    generator_looks_ai = any(keyword in generator for keyword in ai_keywords)

    if has_manifest and validation == "valid" and generator_looks_ai:
        return _verdict(
            "likely_ai",
            0.95,
            "Geçerli bir C2PA manifesti bir AI görüntü aracını adlandırıyor.",
        )

    if has_manifest and validation == "valid" and not generator_looks_ai:
        if classifier_ok and ai_score is not None and ai_score > 0.85:
            return _verdict(
                "uncertain",
                0.55,
                "Manifest otantik görünüyor ancak sınıflandırıcı katılmıyor; sinyaller çelişiyor.",
            )

        return _verdict(
            "likely_authentic",
            0.9,
            "AI olmayan bir araçtan geçerli bir C2PA manifesti mevcut.",
        )

    if has_manifest and validation in ("invalid", "error"):
        return _verdict(
            "uncertain",
            0.6,
            "Görüntü, doğrulaması başarısız olan bir C2PA manifesti taşıyor; iddia edilen geçmiş doğrulanmadı.",
        )

    if classifier_ok and ai_score is not None:
        if ai_score >= 0.7:
            return _verdict(
                "likely_ai",
                round(ai_score, 2),
                "Provenans verisi yok; sınıflandırıcı görüntüyü muhtemelen AI tarafından üretilmiş olarak puanladı.",
            )

        if ai_score <= 0.3:
            return _verdict(
                "likely_authentic",
                round(1 - ai_score, 2),
                "Provenans verisi yok; sınıflandırıcı görüntüyü muhtemelen otantik olarak puanladı.",
            )

        return _verdict(
            "uncertain",
            0.5,
            "Provenans verisi yok ve sınıflandırıcı puanı kesin değil.",
        )

    return _verdict(
        "uncertain",
        0.0,
        "Provenans verisi yok ve sınıflandırıcı kullanılamıyordu.",
    )


def _verdict(verdict: str, confidence: float, explanation: str) -> dict:
    return {
        "verdict": verdict,
        "confidence": confidence,
        "explanation": explanation,
    }

Eşikleri kendi risk profilinize göre değiştirebilirsiniz. Örneğin haber odası ile sosyal medya platformu aynı eşiği kullanmayabilir.

FastAPI uygulaması

Şimdi parçaları birleştirelim.

# main.py
import os
import tempfile
from datetime import datetime, timezone

from fastapi import FastAPI, UploadFile, File, HTTPException
from fastapi.responses import JSONResponse

from provenance import read_provenance
from classifier import classify_image
from verdict import combine_signals

app = FastAPI(title="AI Görüntü Algılayıcı API", version="1.0.0")

ALLOWED_TYPES = {"image/jpeg", "image/png", "image/webp"}
MAX_BYTES = 12 * 1024 * 1024

SIGHTENGINE_USER = os.environ.get("SIGHTENGINE_API_USER", "")
SIGHTENGINE_SECRET = os.environ.get("SIGHTENGINE_API_SECRET", "")


@app.post("/verify")
async def verify(image: UploadFile = File(...)):
    if image.content_type not in ALLOWED_TYPES:
        raise HTTPException(
            status_code=415,
            detail=f"Desteklenmeyen tür {image.content_type}. JPEG, PNG veya WebP gönderin.",
        )

    image_bytes = await image.read()

    if len(image_bytes) == 0:
        raise HTTPException(status_code=400, detail="Boş dosya.")

    if len(image_bytes) > MAX_BYTES:
        raise HTTPException(status_code=413, detail="Dosya 12 MB sınırını aşıyor.")

    suffix = os.path.splitext(image.filename or "")[1] or ".img"

    with tempfile.NamedTemporaryFile(suffix=suffix, delete=False) as tmp:
        tmp.write(image_bytes)
        tmp_path = tmp.name

    try:
        provenance = read_provenance(tmp_path)
    finally:
        os.unlink(tmp_path)

    if SIGHTENGINE_USER and SIGHTENGINE_SECRET:
        classifier = await classify_image(
            image_bytes=image_bytes,
            filename=image.filename or "upload",
            api_user=SIGHTENGINE_USER,
            api_secret=SIGHTENGINE_SECRET,
        )
    else:
        classifier = {
            "available": False,
            "reason": "classifier_not_configured",
        }

    result = combine_signals(provenance, classifier)

    return JSONResponse(
        {
            "verdict": result["verdict"],
            "confidence": result["confidence"],
            "signals": {
                "provenance": {
                    key: provenance.get(key)
                    for key in (
                        "has_manifest",
                        "validation",
                        "claim_generator",
                        "signature_issuer",
                    )
                },
                "classifier": {
                    "available": classifier.get("available", False),
                    "ai_score": classifier.get("ai_score"),
                },
            },
            "explanation": result["explanation"],
            "checked_at": datetime.now(timezone.utc).isoformat(),
        }
    )

Ortam değişkenlerini ayarlayın:

export SIGHTENGINE_API_USER="your-user"
export SIGHTENGINE_API_SECRET="your-secret"

Servisi çalıştırın:

uvicorn main:app --reload

Endpoint:

http://127.0.0.1:8000/verify

curl ile hızlı test:

curl -X POST "http://127.0.0.1:8000/verify" \
  -F "image=@sample.jpg"

Bu yapı, temiz sözleşmeye sahip küçük API servisleri oluşturma yaklaşımıyla uyumludur. Konuyla ilgili daha geniş bakış için yazılımın “headless” hale gelmesi yazısına bakabilirsiniz.

Apidog ile mock ve test

Ön uç ekibinin arka uç bitene kadar beklemesi gerekmez. OpenAPI şemasını Apidog’a aktararak mock sunucu oluşturabilirsiniz.

Mock sunucu oluşturma

Apidog’da:

1. OpenAPI şemasını içe aktarın veya /verify endpoint’ini görsel olarak oluşturun.
2. Yanıt şeması için VerifyResponse modelini tanımlayın.
3. Mock sunucuyu etkinleştirin.
4. Ön uca mock URL’yi verin.

Mock yanıtları için şu durumları tanımlayın:

• likely_authentic: geçerli kamera manifesti.
• likely_ai: manifestte AI aracı adı var.
• uncertain: sınıflandırıcı kullanılamıyor.
• 415: desteklenmeyen dosya türü.
• 413: çok büyük dosya.

Ön uç, gerçek arka uç hazır olmadan yükleme ekranını, sonuç panelini ve hata durumlarını geliştirebilir. Gerçek servis hazır olduğunda sadece base URL değişir.

Uç nokta testleri

Arka uç çalışınca Apidog’da POST /verify isteği oluşturun:

1. Method: POST
2. URL: http://127.0.0.1:8000/verify
3. Body: form-data
4. Alan adı: image
5. Alan tipi: File
6. Test görüntüsünü seçin ve gönderin.

Ardından assertion ekleyin:

• HTTP status 200 olmalı.
• verdict mevcut olmalı.
• verdict, likely_authentic, likely_ai veya uncertain olmalı.
• confidence, 0 ile 1 arasında sayı olmalı.
• signals.provenance.has_manifest boolean olmalı.
• signals.classifier.available boolean olmalı.

Ek test senaryoları:

Test dosyası	Beklenen kontrol
C2PA manifestli görüntü	Provenans dalı çalışır
Manifest olmayan JPEG	Sınıflandırıcı dalı çalışır
12 MB üstü dosya	413 döner
.jpg uzantılı metin dosyası	Geçersiz görüntü olarak ele alınır
Desteklenmeyen MIME tipi	415 döner

Bu testleri kaydedip her değişiklikten sonra tekrar çalıştırabilir veya CI akışına bağlayabilirsiniz.

Sertleştirme ve uç durumlar

Bozuk veya kesik dosyalar

MIME tipi image/jpeg olsa bile dosya bozuk olabilir. C2PA okuyucusu bazı durumlarda hata döndürür. Ek güvenlik için Pillow ile görüntüyü decode edip geçersiz dosyaları 400 ile reddedebilirsiniz.

Örnek:

pip install pillow

from io import BytesIO
from PIL import Image, UnidentifiedImageError


def validate_image_bytes(image_bytes: bytes) -> None:
    try:
        with Image.open(BytesIO(image_bytes)) as img:
            img.verify()
    except UnidentifiedImageError:
        raise HTTPException(status_code=400, detail="Geçersiz görüntü dosyası.")

Bunu image_bytes = await image.read() sonrasında çağırabilirsiniz.

Eksik manifest

Eksik manifest en yaygın durumdur. Bunu hata olarak ele almayın.

Doğru davranış:

{
  "has_manifest": false,
  "validation": "none"
}

Yanlış davranış:

• 500 döndürmek.
• Otomatik olarak “sahte” demek.
• Otomatik olarak “AI” demek.

Sınıflandırıcı timeout

Sınıflandırıcı üçüncü taraf ağ bağımlılığıdır. Timeout ve HTTP hataları normal kabul edilmelidir.

İyi davranış:

{
  "available": false,
  "reason": "classifier_timeout"
}

Bu durumda karar mantığı provenansa döner. Provenans da yoksa uncertain döndürür.

Sahte veya kurcalanmış manifest

Manifestin var olması yeterli değildir. Her zaman doğrulama sonucuna bakın.

• validation_status boşsa: manifest doğrulanmıştır.
• validation_status doluysa: manifest doğrulanmamıştır.

Geçersiz manifest için en güvenli karar genellikle:

{
  "verdict": "uncertain",
  "confidence": 0.6
}

Büyük dosyalar ve kötüye kullanım

Örnekte 12 MB sınırı kullanıldı. Üretimde ayrıca:

• reverse proxy seviyesinde body size limit koyun,
• rate limit uygulayın,
• API anahtarı veya auth ekleyin,
• sınıflandırıcı çağrılarını izleyin,
• maliyet koruması ekleyin.

Gizlilik

Kullanıcı görüntülerini işliyorsunuz. Bu nedenle:

• görüntü baytlarını loglamayın,
• geçici dosyaları hemen silin,
• mümkünse kalıcı depolama yapmayın,
• üçüncü taraf sınıflandırıcıya görüntü gönderdiğinizi gizlilik politikasında belirtin.

Her sinyal neyi yakalar?

Senaryo	C2PA provenans sinyali	Sınıflandırıcı sinyali
İçerik Kimlik Bilgileri yazan araçtan AI görüntüsü	Yakalıyor: manifest üreticiyi adlandırıyor	Genellikle yakalıyor: görsel eserler mevcut
Meta verileri kaldırılmış AI görüntüsü	Kaçırıyor: okunacak manifest yok	Yakalıyor: pikseller üzerinde çalışır
İçerik Kimlik Bilgileri imzalayan kameradan gerçek fotoğraf	Doğruluyor: geçerli manifest, AI olmayan üretici	Sıkıştırma veya düzenlemelerde yanlış pozitif verebilir
Meta verisiz gerçek fotoğraf	Sinyal yok	Olasılıksal tahmin yapar
Sahte veya kurcalanmış manifestli görüntü	Yakalıyor: validation_status hatayı işaretler	Piksellere bağlı
Yeni bir görüntü üretici	Sadece manifest yazarsa yakalar	Eğitim dağılımı dışındaysa kaçırabilir
AI rötuşlu gerçek fotoğraf	Manifest varsa düzenleme geçmişini gösterebilir	Genellikle orta aralıkta belirsiz skor üretir

Özet:

• Provenans kesin ama seyrektir.
• Sınıflandırıcı yaygın uygulanabilir ama olasılıksaldır.
• Birleştirilmiş karar, tek sinyalden daha kullanışlıdır.
• uncertain, hata değil tasarım gereğidir.

Gerçek dünya kullanım alanları

Kullanıcı içerik platformları

Pazar yeri veya sosyal uygulama, yüklenen görüntüleri /verify üzerinden geçirip şu aksiyonları alabilir:

• likely_authentic: izin ver.
• likely_ai: etiketle veya incelemeye gönder.
• uncertain: manuel inceleme kuyruğuna al.

Haber odaları ve doğruluk kontrolü

Editör, viral görüntü için tek çağrıda şunları alır:

• C2PA geçmişi,
• imza doğrulaması,
• sınıflandırıcı skoru,
• insan tarafından okunabilir açıklama.

Sigorta ve talep alımı

Hasar fotoğrafları otomatik olarak kontrol edilebilir. Üretilmiş görünen veya geçersiz manifest taşıyan görüntüler insan incelemesine gönderilebilir.

Dahili varlık boru hatları

Stok görsel veya medya ekipleri, AI tarafından oluşturulmuş görüntüleri etiketlemek veya ayırmak için /verify endpoint’ini ingestion sürecine ekleyebilir.

Provenans farkındalıklı CMS

Daha fazla kamera ve editör Content Credentials destekledikçe CMS, yükleme sırasında manifesti okuyup doğrulanmış rozet gösterebilir. Manifest yoksa sınıflandırıcıya dönebilir.

Sonuç

AI görüntü tespiti tek bir mükemmel testle çözülmez. Daha pratik yaklaşım, bağımsız sinyalleri birleştirip belirsizliği açıkça göstermektir.

Bu rehberde:

• C2PA İçerik Kimlik Bilgileri ile provenans sinyali okuduk.
• Barındırılan sınıflandırıcıdan AI skoru aldık.
• İki sonucu likely_authentic, likely_ai veya uncertain kararına indirdik.
• FastAPI ile POST /verify endpoint’i oluşturduk.
• OpenAPI sözleşmesini Apidog’da mock ve test için kullandık.

Bir sonraki adım olarak /verify şemasını tasarlayın, Apidog’da mock sunucu oluşturun ve test senaryolarınızı kaydedin. Arka uç hazır olduğunda aynı sözleşmeyle mock URL’den canlı API’ye geçebilirsiniz.