EU AI Act Art. 50: KI-Bilder kennzeichnen mit PHP & Symfony – Praxisleitfaden 2026

Ab dem 2. August 2026 wird es ernst: Der EU AI Act verpflichtet zur maschinenlesbaren und menschenlesbaren Kennzeichnung KI-generierter Inhalte – Bilder, Videos, Audio und Text. Wer KI-generierte Produktbilder, Blogbilder oder Social-Media-Grafiken einsetzt, muss handeln.

Für PHP- und Symfony-Entwickler stellt sich die Frage: Welche technischen Standards gibt es, welche Tools sind verfügbar, und was passiert mit Metadaten in der Bildverarbeitungs-Pipeline? Für meine eigene Contao-5.7-Website habe ich mich intensiv mit genau diesen Fragen beschäftigt – und die Antworten sind praxisnäher, als man denkt.

In diesem Artikel erkläre ich die rechtlichen Anforderungen von Artikel 50, stelle die drei technischen Säulen der KI-Bild-Kennzeichnung vor und zeige mit konkreten PHP/Symfony-Code-Beispielen, wie Sie IPTC DigitalSourceType und C2PA-Manifeste in Ihre Bildverarbeitung integrieren – inklusive der Fallstricke, die GD und ImageMagick mitbringen.

Was fordert der EU AI Act Artikel 50 konkret?

Artikel 50 des EU AI Act regelt die Transparenzpflichten für KI-generierte Inhalte. Zwei Absätze sind für Bildkennzeichnung besonders relevant:

• Art. 50(2): Provider von KI-Systemen, die synthetische Inhalte erzeugen, müssen diese in einem maschinenlesbaren Format kennzeichnen – so, dass die KI-Herkunft technisch erkennbar ist.
• Art. 50(4): Deployer, die KI-generierte oder manipulierte Inhalte veröffentlichen (insbesondere Deepfakes), müssen die KI-Herkunft menschenlesbar offenlegen – also sichtbar für den Betrachter.

Provider vs. Deployer

Als Webentwickler sind Sie in der Regel Deployer – Sie nutzen KI-Tools, um Bilder zu erzeugen, und veröffentlichen diese auf Websites. Ihre Pflicht: sichtbar kennzeichnen und dafür sorgen, dass vorhandene Metadaten nicht verschwinden.

Zeitplan und aktueller Stand

Die Strafen sind nicht trivial: Bis zu 15 Millionen Euro oder 3 % des weltweiten Jahresumsatzes (Art. 99 Abs. 4) – je nachdem, welcher Betrag höher ist.

Wichtig: Der Code of Practice, der die technischen Details der Kennzeichnung konkretisiert, ist noch nicht final. Der erste Entwurf vom Dezember 2025 gibt aber bereits eine klare Richtung vor. Die EU-Kommission hat im Februar 2025 einen Omnibus-Vorschlag eingebracht, der für Bestandssysteme eine Verlängerung bis Februar 2027 vorsieht – dieser ist allerdings nicht beschlossen und sollte nicht als Grundlage für Untätigkeit dienen.

Ausnahmen gibt es für rein assistive Bearbeitung (Helligkeit, Kontrast, Zuschnitt) und Inhalte unter redaktioneller Kontrolle, bei denen ein Mensch die inhaltliche Verantwortung trägt.

Die drei Säulen der KI-Bild-Kennzeichnung

Die technische Umsetzung der Kennzeichnungspflicht stützt sich auf drei komplementäre Ansätze. Keiner davon ist allein ausreichend – die Kombination macht die Lösung robust.

C2PA – Coalition for Content Provenance and Authenticity

C2PA ist der ambitionierteste Standard: Ein kryptografisch signiertes Manifest wird direkt in die Bilddatei eingebettet. Es enthält die gesamte Herkunftsgeschichte – wer das Bild erzeugt hat, mit welchem Tool, wann und wie es verändert wurde.

C2PA ist der Standard, auf den sich die großen KI-Anbieter geeinigt haben. Er ist tamper-evident – Veränderungen am Bild nach der Signatur werden erkannt. Aber er ist nicht tamper-proof: Wer die Metadaten gezielt entfernt, kann die Kennzeichnung umgehen.

IPTC DigitalSourceType

Der IPTC-Standard ist das Arbeitspferd der Bildmetadaten – etabliert, breit unterstützt und mit PHP-Bordmitteln lesbar. Das Feld DigitalSourceType klassifiziert die Herkunft eines Bildes:

Seit IPTC 2025.1 gibt es zusätzliche Felder, die noch mehr Kontext liefern:

• AIPromptInformation – Der verwendete Prompt
• AISystemUsed – Name des KI-Systems (z. B. "DALL-E 3")
• AIPromptWriterName – Wer den Prompt geschrieben hat

IPTC-Metadaten sind der pragmatischste Ansatz für PHP-Entwickler: Sie lassen sich mit ExifTool, ImageMagick und sogar mit PHP-Bordmitteln (iptcembed()) lesen und schreiben.

Unsichtbare Wasserzeichen

Unsichtbare Wasserzeichen – wie Googles SynthID – werden direkt in die Pixeldaten eingebettet. Sie überleben Komprimierung, Zuschnitt und sogar Screenshots. Der Vorteil: Sie lassen sich nicht durch einfaches Metadaten-Strippen entfernen.

Für PHP-Entwickler ist dieser Ansatz allerdings nicht selbst implementierbar. Wasserzeichen werden auf Seiten der KI-Provider eingebettet und erfordern spezialisierte Decoder zur Erkennung. Die Verantwortung liegt hier klar beim Provider – nicht beim Deployer.

Was machen die KI-Anbieter bereits?

Bevor Sie selbst Metadaten setzen, lohnt sich ein Blick darauf, was die großen KI-Anbieter bereits liefern:

Takeaway: Wenn Sie DALL-E oder Firefly nutzen, sind die Metadaten bereits vorhanden. Ihre Aufgabe als Deployer: Diese Metadaten nicht in der Bildverarbeitungs-Pipeline verlieren. Bei Stable Diffusion oder lokalen Modellen müssen Sie die Kennzeichnung selbst hinzufügen.

Die PHP/Symfony-Toolbox

Für die technische Umsetzung in PHP stehen verschiedene Tools zur Verfügung. Nicht alle können alles – die folgende Übersicht hilft bei der Auswahl:

Die wichtigste Erkenntnis: GD löscht alle Metadaten – EXIF, IPTC, XMP, C2PA – beim Resize oder Konvertieren. Wenn Ihre Bildverarbeitungs-Pipeline GD nutzt, verlieren Sie jede KI-Kennzeichnung. Dazu mehr im Abschnitt zur Metadaten-Erhaltung.

Praxis: IPTC DigitalSourceType mit ExifTool und Symfony setzen

ExifTool von Phil Harvey ist das Schweizer Taschenmesser für Bild-Metadaten. In Kombination mit Symfonys Process-Komponente lässt sich ein sauberer Service bauen, der KI-Bilder kennzeichnet.

ExifTool installieren

# Debian/Ubuntu
sudo apt-get install libimage-exiftool-perl

# macOS
brew install exiftool

# Version prüfen
exiftool -ver

Symfony-Service AiImageLabeler

<?php

declare(strict_types=1);

namespace App\Service;

use Symfony\Component\Process\Exception\ProcessFailedException;
use Symfony\Component\Process\Process;

final class AiImageLabeler
{
    public function __construct(
        private readonly string $exiftoolBinary = 'exiftool',
    ) {
    }

    /**
     * Kennzeichnet ein Bild als KI-generiert (IPTC DigitalSourceType).
     *
     * @param string $filePath   Absoluter Pfad zur Bilddatei
     * @param string $sourceType IPTC DigitalSourceType-Wert
     * @param string $aiSystem   Name des KI-Systems (z. B. "DALL-E 3")
     */
    public function labelAsAiGenerated(
        string $filePath,
        string $sourceType = 'trainedAlgorithmicMedia',
        string $aiSystem = '',
    ): void {
        $this->validateFile($filePath);

        $args = [
            $this->exiftoolBinary,
            '-overwrite_original',
            '-XMP-iptcExt:DigitalSourceType=' . $sourceType,
        ];

        if ($aiSystem !== '') {
            $args[] = '-XMP-iptcExt:AISystemUsed=' . $aiSystem;
        }

        $args[] = $filePath;

        $this->runProcess($args);
    }

    /**
     * Prüft, ob ein Bild als KI-generiert gekennzeichnet ist.
     */
    public function isAiGenerated(string $filePath): bool
    {
        $this->validateFile($filePath);

        $process = new Process([
            $this->exiftoolBinary,
            '-j',
            '-XMP-iptcExt:DigitalSourceType',
            $filePath,
        ]);
        $process->run();

        if (!$process->isSuccessful()) {
            return false;
        }

        $data = json_decode($process->getOutput(), true);

        if (!is_array($data) || !isset($data[0]['DigitalSourceType'])) {
            return false;
        }

        return in_array($data[0]['DigitalSourceType'], [
            'trainedAlgorithmicMedia',
            'compositeSynthetic',
        ], true);
    }

    /**
     * Kopiert alle Metadaten von einer Quelldatei auf eine Zieldatei.
     * Nützlich nach einer GD-Verarbeitung, die Metadaten gelöscht hat.
     */
    public function copyMetadata(string $sourceFile, string $targetFile): void
    {
        $this->validateFile($sourceFile);
        $this->validateFile($targetFile);

        $this->runProcess([
            $this->exiftoolBinary,
            '-overwrite_original',
            '-TagsFromFile',
            $sourceFile,
            '-all:all',
            $targetFile,
        ]);
    }

    private function validateFile(string $filePath): void
    {
        if (!file_exists($filePath)) {
            throw new \InvalidArgumentException(
                sprintf('File not found: %s', $filePath),
            );
        }
    }

    private function runProcess(array $args): void
    {
        $process = new Process($args);
        $process->run();

        if (!$process->isSuccessful()) {
            throw new ProcessFailedException($process);
        }
    }
}

Service nutzen

// In einem Controller oder Command:

$labeler = new AiImageLabeler();

// Bild als KI-generiert kennzeichnen
$labeler->labelAsAiGenerated(
    '/path/to/ai-generated-image.jpg',
    'trainedAlgorithmicMedia',
    'DALL-E 3',
);

// Prüfen, ob ein Bild KI-generiert ist
if ($labeler->isAiGenerated('/path/to/image.jpg')) {
    // Label anzeigen, Alt-Text ergänzen etc.
}

// Metadaten nach GD-Verarbeitung wiederherstellen
$labeler->copyMetadata(
    '/path/to/original.jpg',
    '/path/to/resized.jpg',
);

In einem Symfony-Projekt registrieren Sie den Service über Autowiring – die Dependency Injection übernimmt den Rest. Den exiftoolBinary-Pfad können Sie bei Bedarf über einen Parameter in services.yaml konfigurieren.

Alternative: DigitalSourceType mit Contao lesen (ohne ExifTool)

Contao 5.7 bringt mit contao/image einen eigenen MetadataReaderWriter mit, der XMP-Metadaten in reinem PHP lesen kann – ganz ohne ExifTool oder andere CLI-Abhängigkeiten. Die Klasse XmpFormat kennt den Iptc4xmpExt-Namespace bereits nativ:

use Contao\Image\Metadata\MetadataReaderWriter;

$readerWriter = new MetadataReaderWriter();
$metadata = $readerWriter->parse('/path/to/image.jpg');
$xmp = $metadata->getFormat('xmp');

$sourceType = $xmp['http://iptc.org/std/Iptc4xmpExt/2008-02-29/']['DigitalSourceType'] ?? [];

if (in_array('trainedAlgorithmicMedia', (array) $sourceType, true)) {
    // Bild ist als KI-generiert gekennzeichnet
}

Unter der Haube nutzt XmpFormat::parse() PHP-eigenes DOMDocument, um die XMP-Daten aus der Bilddatei zu extrahieren – unterstützt werden JPEG, PNG, WebP, AVIF, HEIC und JXL. Für das Schreiben neuer Metadaten-Werte in beliebige Dateien bleibt ExifTool die bessere Wahl: Contaos MetadataReaderWriter ist primär für die Resize-Pipeline konzipiert und schreibt Metadaten nur im Kontext von applyCopyrightToFile().

C2PA-Manifeste mit PHP signieren

C2PA geht über einfache Metadaten hinaus: Ein kryptografisch signiertes Manifest dokumentiert die gesamte Herkunftskette eines Bildes. Mit dem c2patool der C2PA-Organisation lässt sich das auch in PHP-Workflows integrieren.

c2patool installieren

# macOS
brew install c2patool

# Linux (Rust-basiert, Cargo)
cargo install c2patool

# Version prüfen
c2patool --version

C2PA-Manifest per PHP einbetten

<?php

declare(strict_types=1);

namespace App\Service;

use Symfony\Component\Process\Exception\ProcessFailedException;
use Symfony\Component\Process\Process;

final class C2paManifestService
{
    public function __construct(
        private readonly string $c2patoolBinary = 'c2patool',
        private readonly string $certPath = '',
        private readonly string $keyPath = '',
    ) {
    }

    /**
     * Bettet ein C2PA-Manifest in eine Bilddatei ein.
     */
    public function embedManifest(
        string $filePath,
        string $claimGenerator = 'VanHulst/1.0',
        string $title = '',
    ): void {
        $manifest = [
            'claim_generator' => $claimGenerator,
            'title' => $title ?: basename($filePath),
            'assertions' => [
                [
                    'label' => 'c2pa.actions',
                    'data' => [
                        'actions' => [
                            [
                                'action' => 'c2pa.created',
                                'digitalSourceType' => 'http://cv.iptc.org/newscodes/digitalsourcetype/trainedAlgorithmicMedia',
                                'softwareAgent' => $claimGenerator,
                            ],
                        ],
                    ],
                ],
                [
                    'label' => 'stds.schema-org.CreativeWork',
                    'data' => [
                        '@context' => 'https://schema.org',
                        '@type' => 'CreativeWork',
                        'author' => [
                            [
                                '@type' => 'Person',
                                'name' => 'Andreas van Hulst',
                            ],
                        ],
                    ],
                ],
            ],
        ];

        $manifestFile = tempnam(sys_get_temp_dir(), 'c2pa_') . '.json';
        file_put_contents($manifestFile, json_encode($manifest, JSON_PRETTY_PRINT));

        try {
            $args = [
                $this->c2patoolBinary,
                $filePath,
                '--manifest',
                $manifestFile,
                '--output',
                $filePath,
                '--force',
            ];

            if ($this->certPath !== '' && $this->keyPath !== '') {
                $args[] = '--signer-path';
                $args[] = $this->certPath;
                $args[] = '--private-key';
                $args[] = $this->keyPath;
            }

            $process = new Process($args);
            $process->run();

            if (!$process->isSuccessful()) {
                throw new ProcessFailedException($process);
            }
        } finally {
            unlink($manifestFile);
        }
    }

    /**
     * Liest das C2PA-Manifest einer Bilddatei aus.
     */
    public function readManifest(string $filePath): ?array
    {
        $process = new Process([
            $this->c2patoolBinary,
            $filePath,
            '--detailed',
        ]);
        $process->run();

        if (!$process->isSuccessful()) {
            return null;
        }

        return json_decode($process->getOutput(), true);
    }
}

Wichtig: Für produktive C2PA-Signaturen benötigen Sie ein X.509-Zertifikat. Der finale Code of Practice (erwartet Juni 2026) wird voraussichtlich festlegen, welche Zertifikatsanforderungen gelten. Für Tests funktioniert c2patool auch mit selbst-signierten Zertifikaten.

Metadaten-Erhaltung in der Bildverarbeitung

Die schönste KI-Kennzeichnung nutzt nichts, wenn sie in der Bildverarbeitungs-Pipeline verloren geht. Und genau das passiert mit der meistgenutzten PHP-Bildbearbeitungsbibliothek.

Das GD-Problem

Die GD-Library – Standard in fast jeder PHP-Installation – löscht alle Metadaten beim Resize, Konvertieren oder Zuschneiden. EXIF, IPTC, XMP, C2PA – alles weg.

// WARNUNG: Dieser Code löscht alle Metadaten!
$original = imagecreatefromjpeg('/path/to/ai-image.jpg');
$resized = imagecreatetruecolor(800, 600);
imagecopyresampled($resized, $original, 0, 0, 0, 0, 800, 600, 1920, 1080);
imagejpeg($resized, '/path/to/resized.jpg', 85);
// → Alle KI-Kennzeichnungen sind verloren!

Das ist kein Bug – es ist by Design. GD arbeitet ausschließlich auf Pixeldaten und hat kein Konzept von Metadaten.

ImageMagick als Alternative

ImageMagick (via der PHP-Extension imagick) erhält Metadaten standardmäßig:

$imagick = new \Imagick('/path/to/ai-image.jpg');
$imagick->resizeImage(800, 600, \Imagick::FILTER_LANCZOS, 1);
$imagick->writeImage('/path/to/resized.jpg');
// → IPTC, EXIF, XMP bleiben erhalten!

Das allein ist ein starkes Argument, ImageMagick statt GD für die Bildverarbeitung einzusetzen – nicht nur für KI-Kennzeichnung, sondern generell für professionelle Bildverarbeitung.

Contao-CMS Konfiguration

Contao unterstützt über die Konfiguration preserve_metadata_fields die Erhaltung bestimmter Metadaten beim Resize. Um DigitalSourceType zu erhalten, müssen Sie den Iptc4xmpExt-Namespace explizit in die XMP-Konfiguration aufnehmen:

# config/config.yml
contao:
    image:
        preserve_metadata_fields:
            xmp:
                'http://purl.org/dc/elements/1.1/':
                    - rights
                    - creator
                'http://ns.adobe.com/photoshop/1.0/':
                    - Source
                    - Credit
                'http://iptc.org/std/Iptc4xmpExt/2008-02-29/':
                    - DigitalSourceType
                    - AISystemUsed
            iptc:
                - '2#116'
                - '2#080'
                - '2#115'
                - '2#110'
            exif:
                IFD0:
                    - Copyright
                    - Artist

Wichtig: Wenn Sie preserve_metadata_fields setzen, ersetzt das die Defaults komplett. Die Standard-Felder (dc:rights, dc:creator, photoshop:Source, photoshop:Credit für XMP; 2#116, 2#080, 2#115, 2#110 für IPTC; Copyright, Artist für EXIF) müssen alle mit deklariert werden – sonst gehen Copyright-Metadaten beim Resize verloren.

So funktioniert die Pipeline: Contaos Resizer liest die Originaldaten via MetadataReaderWriter::parse(), Imagine (GD oder ImageMagick) strippt beim Resize alle Metadaten, dann schreibt applyCopyrightToFile() die konfigurierten Felder zurück ins Ergebnis. Mit dieser Konfiguration überlebt DigitalSourceType jeden Resize – unabhängig davon, ob Contao intern GD oder ImageMagick nutzt.

Workflow-Empfehlung

Der sicherste Ablauf für KI-Bilder in Ihrer Pipeline:

1. Upload – Bild empfangen und Original-Metadaten lesen
2. Prüfen – isAiGenerated() aufrufen, Ergebnis speichern
3. Verarbeiten – Resize, Crop, Optimierung (mit ImageMagick, nicht GD)
4. Wiederherstellen – Falls GD verwendet wurde: copyMetadata() aufrufen
5. Verifizieren – Metadaten im verarbeiteten Bild prüfen

Contao-Tipp: Konfigurieren Sie preserve_metadata_fields (siehe oben) und der MetadataReaderWriter übernimmt die Metadaten-Erhaltung automatisch bei jedem Resize – unabhängig davon, ob Contao intern GD oder ImageMagick nutzt.

Checkliste: KI-Bild-Compliance

1. Pipeline prüfen – Nutzt Ihre Bildverarbeitung GD oder ImageMagick? GD löscht alle Metadaten.
2. IPTC DigitalSourceType setzen – Für jedes KI-generierte Bild trainedAlgorithmicMedia als Wert setzen.
3. Metadaten erhalten – ImageMagick nutzen oder Metadaten nach GD-Verarbeitung mit ExifTool wiederherstellen.
4. Menschenlesbar kennzeichnen – Sichtbaren Hinweis auf der Website anzeigen (Bildunterschrift, Badge, Alt-Text).
5. Upload-Workflow anpassen – Beim Upload prüfen, ob KI-Metadaten vorhanden sind, und diese nicht strippen.
6. Tests schreiben – Automatisierte Tests, die prüfen, ob Metadaten nach der Verarbeitung erhalten bleiben.
7. Dokumentation erstellen – Intern festhalten, welche Bilder KI-generiert sind und welche Kennzeichnungsmethoden verwendet werden.
8. Code of Practice verfolgen – Den finalen Code of Practice (erwartet Juni 2026) beobachten und Workflow bei Bedarf anpassen.

Kritische Einordnung

Dafür spricht

• Klarer rechtlicher Rahmen – Art. 50 gibt eine eindeutige Richtung vor. Kein Interpretationsspielraum bei der Frage, ob gekennzeichnet werden muss.
• Etablierte Standards – C2PA und IPTC sind keine experimentellen Formate. Sie werden von der gesamten Medienindustrie unterstützt.
• PHP-Tooling funktioniert – ExifTool, ImageMagick und die verfügbaren PHP-Bibliotheken sind produktionsreif.
• Provider liefern – DALL-E, Firefly und Imagen betten bereits konforme Metadaten ein.

Dagegen spricht

• Code of Practice nicht final – Die technischen Details sind noch nicht verbindlich festgelegt. Wer jetzt implementiert, muss möglicherweise nachjustieren.
• C2PA trivial entfernbar – Ein einfaches Metadaten-Strippen reicht, um die Kennzeichnung zu umgehen. Der Standard ist tamper-evident, aber nicht tamper-proof.
• Kein Drop-in-Paket – Es gibt (noch) kein composer require eu-ai-act/compliance-bundle. Die Integration erfordert manuelle Arbeit.
• Wasserzeichen nicht praktikabel – Unsichtbare Wasserzeichen lassen sich in PHP nicht selbst einbetten oder verifizieren. Die Verantwortung liegt beim Provider.

Meine Einschätzung

Mein pragmatischer Ansatz: IPTC DigitalSourceType + ImageMagick + sichtbare Labels auf der Website. Das deckt die Deployer-Pflichten ab und ist heute umsetzbar. C2PA-Manifeste ergänze ich bei Bedarf – etwa für Projektbilder, bei denen die Herkunftskette dokumentiert werden soll. Over-Engineering lohnt sich nicht, solange der Code of Practice nicht final ist.

Die größte Gefahr sehe ich nicht in fehlender Technologie, sondern in unbewusstem Metadaten-Verlust – weil GD oder ein zu aggressiver Bildoptimierer die Kennzeichnung stillschweigend entfernt. Prüfen Sie Ihre Pipeline. Das ist der wichtigste Schritt.

Fazit

Die Kennzeichnungspflicht für KI-generierte Bilder kommt – und sie ist technisch umsetzbar. Die Standards existieren, die Tools funktionieren, und die großen KI-Anbieter liefern bereits konforme Metadaten. Als PHP- und Symfony-Entwickler liegt Ihre Hauptaufgabe darin, diese Metadaten in der Bildverarbeitungs-Pipeline zu erhalten und menschenlesbare Labels auf der Website anzuzeigen.

Für meine eigene Contao-5.7-Website setze ich auf den pragmatischen Dreiklang: IPTC DigitalSourceType mit ExifTool setzen, ImageMagick statt GD für die Bildverarbeitung nutzen, und sichtbare Hinweise in den Templates ergänzen. Kein Over-Engineering, kein Warten auf den perfekten Standard – sondern eine solide Basis, die sich anpassen lässt, wenn der Code of Practice final ist.

Mein Rat? Prüfen Sie als Erstes Ihre Bildverarbeitungs-Pipeline. Wenn dort GD im Einsatz ist, verlieren Sie bereits heute Metadaten – nicht nur KI-Kennzeichnungen, sondern auch Copyright-Informationen und Urheberrechtshinweise. Die Umstellung auf ImageMagick lohnt sich unabhängig vom AI Act.