Blog & Tutorials

Schema Markup für Entwickler

Schema Markup ist das Einzige im SEO-Bereich, wo du Google direkt sagen kannst was deine Seite bedeutet — nicht nur worum es geht.

11.05.2026 XimenesBenz 27 Min. Lesezeit
Schema Markup für Entwickler
Inhalt

der vollständige Praxis-Guide mit JSON-LD

Schema Markup ist das Einzige im SEO-Bereich, wo du Google direkt sagen kannst was deine Seite bedeutet — nicht nur worum es geht. Dieser Guide zeigt dir welche Typen wirklich etwas bringen, wie du sie korrekt implementierst und wie du die häufigsten Fehler vor dem nächsten Google-Crawl behebst.

Was Schema Markup wirklich ist — und was nicht

Schema.org ist ein gemeinsames Vokabular von Google, Microsoft, Yahoo und Yandex, mit dem du Webinhalte maschinenlesbar beschreiben kannst. Die Implementierung als JSON-LD (JavaScript Object Notation for Linked Data) ist der von Google empfohlene Weg seit 2015 — und aus gutem Grund.

JSON-LD vs. Microdata vs. RDFa — warum JSON-LD gewinnt:

<!-- Microdata: Schema-Attribute direkt im HTML — schwer zu warten, klammert sich ans Markup -->
<article itemscope itemtype="https://schema.org/BlogPosting">
  <h1 itemprop="headline">Mein Artikel</h1>
  <span itemprop="author" itemscope itemtype="https://schema.org/Person">
    <span itemprop="name">Max Mustermann</span>
  </span>
</article>

<!-- JSON-LD: Sauber getrennt vom HTML, unabhängig von der Struktur -->
<script type="application/ld+json">
{
  "@context": "https://schema.org",
  "@type": "BlogPosting",
  "headline": "Mein Artikel",
  "author": {
    "@type": "Person",
    "name": "Max Mustermann"
  }
}
</script>

Mit JSON-LD liegt dein Schema im <head> oder <body> — komplett unabhängig vom HTML. Du kannst es in PHP generieren, cachen, validieren, ohne auch nur ein HTML-Tag anzufassen. Das ist der einzige richtige Weg in 2026.

Was Schema Markup tatsächlich bringt:

Rich Results in der Google-Suche — die Sternchen-Bewertungen, die FAQ-Boxen, die Rezept-Kalorien, die Event-Daten. Diese nehmen mehr Platz in den Suchergebnissen ein, erhöhen die Click-Through-Rate und verbessern nachweislich das Ranking für strukturierte Inhaltstypen.

Was es nicht bringt: Magische Ranking-Boosts ohne passenden Inhalt. Schema Markup verstärkt was bereits vorhanden ist — es ersetzt keine guten Inhalte.

Die 5 Schema-Typen die wirklich ranken

1. Article / BlogPosting — Pflicht für jeden Blog

Jeder Blogartikel sollte Article oder BlogPosting haben. Google nutzt es für News-Karussells, Discover-Feed und die datePublished-Anzeige in den Suchergebnissen.

<script type="application/ld+json">
{
  "@context": "https://schema.org",
  "@type": "BlogPosting",
  "headline": "PHP-Seiten auf unter 50ms bringen",
  "description": "Konkrete Maßnahmen für schnellere TTFB ohne Framework-Wechsel.",
  "image": {
    "@type": "ImageObject",
    "url": "https://deine-domain.de/img/artikel/php-performance.webp",
    "width": 1200,
    "height": 630
  },
  "author": {
    "@type": "Person",
    "name": "Max Mustermann",
    "url": "https://deine-domain.de/user/max/",
    "sameAs": [
      "https://github.com/maxmustermann",
      "https://linkedin.com/in/maxmustermann"
    ]
  },
  "publisher": {
    "@type": "Organization",
    "name": "3ernert.com",
    "logo": {
      "@type": "ImageObject",
      "url": "https://deine-domain.de/img/logo.png",
      "width": 200,
      "height": 60
    }
  },
  "datePublished": "2026-05-06T10:00:00+02:00",
  "dateModified": "2026-05-07T14:30:00+02:00",
  "mainEntityOfPage": {
    "@type": "WebPage",
    "@id": "https://deine-domain.de/artikel/php-unter-50ms/"
  },
  "keywords": ["PHP", "Performance", "TTFB", "OPcache"],
  "articleSection": "Webentwicklung"
}
</script>

Die häufigsten Fehler bei Article:

  • headline länger als 110 Zeichen → Google schneidet ab
  • image fehlt → kein Rich Result im Discover-Feed möglich
  • datePublished ohne Zeitzone → immer ISO 8601 mit Offset (+02:00)
  • author.name ist der Domain-Name statt einer Person → Google bevorzugt Person über Organization für Blogartikel

PHP-Generator für BlogPosting:

<?php
function generateArticleSchema(array $post, string $baseUrl): string {
    $schema = [
        '@context' => 'https://schema.org',
        '@type'    => 'BlogPosting',
        'headline' => mb_substr($post['title'], 0, 110),
        'description' => $post['excerpt'],
        'datePublished' => (new \DateTime($post['published_at']))->format(\DateTime::ATOM),
        'dateModified'  => (new \DateTime($post['updated_at'] ?? $post['published_at']))->format(\DateTime::ATOM),
        'author' => [
            '@type' => 'Person',
            'name'  => $post['author_name'],
            'url'   => $baseUrl . '/user/' . urlencode($post['author_username']) . '/',
        ],
        'publisher' => [
            '@type' => 'Organization',
            'name'  => '3ernert.com',
            'logo'  => [
                '@type'  => 'ImageObject',
                'url'    => $baseUrl . '/img/logo.png',
                'width'  => 200,
                'height' => 60,
            ],
        ],
        'mainEntityOfPage' => [
            '@type' => 'WebPage',
            '@id'   => $baseUrl . '/artikel/' . $post['slug'] . '/',
        ],
    ];

    if (!empty($post['cover_image'])) {
        $schema['image'] = [
            '@type'  => 'ImageObject',
            'url'    => str_starts_with($post['cover_image'], 'http')
                            ? $post['cover_image']
                            : $baseUrl . $post['cover_image'],
            'width'  => 1200,
            'height' => 630,
        ];
    }

    return '<script type="application/ld+json">'
        . json_encode($schema, JSON_UNESCAPED_SLASHES | JSON_UNESCAPED_UNICODE)
        . '</script>';
}

2. FAQPage — der einfachste Weg zu mehr SERP-Fläche

FAQ-Schema ist das Verhältnis-mäßig einfachste Markup mit dem höchsten visuellen Impact: Google zeigt die Fragen direkt unter deinem Suchergebnis an, was die Ergebnis-Höhe verdoppelt bis verdreifacht.

<script type="application/ld+json">
{
  "@context": "https://schema.org",
  "@type": "FAQPage",
  "mainEntity": [
    {
      "@type": "Question",
      "name": "Was ist der Unterschied zwischen Laravel und Symfony?",
      "acceptedAnswer": {
        "@type": "Answer",
        "text": "Laravel fokussiert auf Entwicklerproduktivität mit einem umfangreichen Ökosystem und ist ideal für Rapid Development. Symfony bietet mehr Kontrolle, bessere Langzeit-Stabilität durch LTS-Versionen und eignet sich für Enterprise-Projekte."
      }
    },
    {
      "@type": "Question",
      "name": "Wann sollte man Vanilla PHP statt einem Framework nutzen?",
      "acceptedAnswer": {
        "@type": "Answer",
        "text": "Vanilla PHP ist die richtige Wahl bei kleinen bis mittelgroßen Projekten mit klaren Anforderungen, bei hohen Performance-Anforderungen (unter 20ms TTFB) oder wenn das Projekt über viele Jahre ohne externe Abhängigkeiten wartbar bleiben soll."
      }
    },
    {
      "@type": "Question",
      "name": "Wie schnell sollte ein PHP-Server antworten?",
      "acceptedAnswer": {
        "@type": "Answer",
        "text": "Google bewertet TTFB unter 200ms als 'gut', unter 100ms als 'sehr gut'. Mit OPcache, optimierten DB-Queries und Output Buffering sind unter 50ms auf einem normalen VPS realistisch."
      }
    }
  ]
}
</script>

Regeln für FAQ-Schema die Google wirklich zeigt:

  • Maximal 10 Fragen — mehr werden nicht angezeigt, aber auch nicht abgestraft
  • Die Antwort muss vollständig im text-Feld stehen (kein "Lies mehr unter...")
  • Kein HTML in name oder text — nur Plain Text, maximal ein Zeilenumbruch
  • Die Fragen müssen tatsächlich auf der Seite sichtbar sein (kein Schema ohne sichtbaren Content)

PHP-Helper für FAQ aus einem Array:

<?php
function generateFAQSchema(array $faqs): string {
    $questions = array_map(fn($faq) => [
        '@type' => 'Question',
        'name'  => strip_tags($faq['question']),
        'acceptedAnswer' => [
            '@type' => 'Answer',
            'text'  => strip_tags($faq['answer']),
        ],
    ], array_slice($faqs, 0, 10)); // Max. 10

    $schema = [
        '@context'   => 'https://schema.org',
        '@type'      => 'FAQPage',
        'mainEntity' => $questions,
    ];

    return '<script type="application/ld+json">'
        . json_encode($schema, JSON_UNESCAPED_SLASHES | JSON_UNESCAPED_UNICODE)
        . '</script>';
}

// Verwendung:
$faqs = [
    ['question' => 'Was ist OPcache?', 'answer' => 'OPcache ist...'],
    ['question' => 'Wie aktiviere ich OPcache?', 'answer' => 'In der php.ini...'],
];
echo generateFAQSchema($faqs);

3. HowTo — strukturierte Anleitungen mit Schritten

HowTo-Schema ist ideal für Tutorial-Artikel, Schritt-für-Schritt-Guides und technische Anleitungen. Google zeigt die einzelnen Schritte direkt in den Suchergebnissen.

<script type="application/ld+json">
{
  "@context": "https://schema.org",
  "@type": "HowTo",
  "name": "OPcache in PHP korrekt konfigurieren",
  "description": "Schritt-für-Schritt-Anleitung zur optimalen OPcache-Konfiguration für PHP 8.x in Produktion.",
  "totalTime": "PT15M",
  "estimatedCost": {
    "@type": "MonetaryAmount",
    "currency": "EUR",
    "value": "0"
  },
  "tool": [
    {
      "@type": "HowToTool",
      "name": "SSH-Zugang zum Server"
    },
    {
      "@type": "HowToTool",
      "name": "Texteditor (nano, vim)"
    }
  ],
  "step": [
    {
      "@type": "HowToStep",
      "position": 1,
      "name": "OPcache-Status prüfen",
      "text": "Prüfe ob OPcache bereits aktiv ist: php -m | grep -i opcache. Erscheint 'Zend OPcache' in der Ausgabe, ist das Modul geladen.",
      "url": "https://deine-domain.de/artikel/opcache-guide/#schritt-1"
    },
    {
      "@type": "HowToStep",
      "position": 2,
      "name": "php.ini öffnen",
      "text": "Finde den Pfad zur aktiven php.ini mit: php --ini. Öffne die Datei mit einem Texteditor mit Root-Rechten.",
      "url": "https://deine-domain.de/artikel/opcache-guide/#schritt-2"
    },
    {
      "@type": "HowToStep",
      "position": 3,
      "name": "Konfiguration anpassen",
      "text": "Setze opcache.enable=1, opcache.memory_consumption=128, opcache.validate_timestamps=0 für Produktionsumgebungen.",
      "url": "https://deine-domain.de/artikel/opcache-guide/#schritt-3"
    },
    {
      "@type": "HowToStep",
      "position": 4,
      "name": "PHP-FPM neu starten",
      "text": "Aktiviere die Änderungen mit: sudo systemctl restart php8.3-fpm. Prüfe danach den Status mit: opcache_get_status().",
      "url": "https://deine-domain.de/artikel/opcache-guide/#schritt-4"
    }
  ]
}
</script>

4. LocalBusiness — für Service-Seiten und Freelancer

Wer Dienstleistungen anbietet, sollte LocalBusiness oder das spezifischere ProfessionalService Schema auf der Kontakt/Service-Seite haben. Es befähigt den Knowledge Graph-Eintrag und lokale Suchergebnisse.

<script type="application/ld+json">
{
  "@context": "https://schema.org",
  "@type": "ProfessionalService",
  "name": "3ernert.com Webentwicklung",
  "description": "Professionelle Webentwicklung mit Fokus auf Performance, SEO und modernes Design.",
  "url": "https://deine-domain.de",
  "email": "info@deine-domain.de",
  "address": {
    "@type": "PostalAddress",
    "addressLocality": "Kassel",
    "addressRegion": "Hessen",
    "addressCountry": "DE"
  },
  "geo": {
    "@type": "GeoCoordinates",
    "latitude": 51.3127,
    "longitude": 9.4797
  },
  "areaServed": {
    "@type": "Country",
    "name": "Deutschland"
  },
  "priceRange": "€€",
  "openingHoursSpecification": [
    {
      "@type": "OpeningHoursSpecification",
      "dayOfWeek": ["Monday", "Tuesday", "Wednesday", "Thursday", "Friday"],
      "opens": "09:00",
      "closes": "18:00"
    }
  ],
  "hasOfferCatalog": {
    "@type": "OfferCatalog",
    "name": "Webentwicklungs-Dienstleistungen",
    "itemListElement": [
      {
        "@type": "Offer",
        "itemOffered": {
          "@type": "Service",
          "name": "Maßgeschneiderte Webentwicklung",
          "description": "Custom CMS, Backends und Webanwendungen in PHP und JavaScript."
        }
      },
      {
        "@type": "Offer",
        "itemOffered": {
          "@type": "Service",
          "name": "SEO & Performance Optimierung",
          "description": "Technisches SEO, Core Web Vitals, Ladezeit-Optimierung."
        }
      }
    ]
  },
  "sameAs": [
    "https://github.com/dein-profil",
    "https://linkedin.com/in/dein-profil"
  ]
}
</script>

5. BreadcrumbList — Navigation die Google versteht

Breadcrumb-Schema ist ein unterschätztes Quick-Win. Google zeigt den Pfad statt der vollständigen URL in den Suchergebnissen — das macht Ergebnisse klarer und erhöht die CTR.

<script type="application/ld+json">
{
  "@context": "https://schema.org",
  "@type": "BreadcrumbList",
  "itemListElement": [
    {
      "@type": "ListItem",
      "position": 1,
      "name": "Home",
      "item": "https://deine-domain.de/"
    },
    {
      "@type": "ListItem",
      "position": 2,
      "name": "Blog",
      "item": "https://deine-domain.de/blog"
    },
    {
      "@type": "ListItem",
      "position": 3,
      "name": "PHP Performance Guide",
      "item": "https://deine-domain.de/artikel/php-unter-50ms/"
    }
  ]
}
</script>

PHP-Generator für dynamische Breadcrumbs:

<?php
function generateBreadcrumbSchema(array $crumbs, string $baseUrl): string {
    $items = [];
    foreach ($crumbs as $i => $crumb) {
        $items[] = [
            '@type'    => 'ListItem',
            'position' => $i + 1,
            'name'     => $crumb['name'],
            'item'     => str_starts_with($crumb['url'], 'http')
                            ? $crumb['url']
                            : $baseUrl . $crumb['url'],
        ];
    }

    return '<script type="application/ld+json">'
        . json_encode([
            '@context'        => 'https://schema.org',
            '@type'           => 'BreadcrumbList',
            'itemListElement' => $items,
        ], JSON_UNESCAPED_SLASHES | JSON_UNESCAPED_UNICODE)
        . '</script>';
}

// Verwendung:
echo generateBreadcrumbSchema([
    ['name' => 'Home',  'url' => '/'],
    ['name' => 'Blog',  'url' => '/blog'],
    ['name' => 'Artikel-Titel', 'url' => '/artikel/mein-artikel/'],
], 'https://deine-domain.de');

Schema testen — bevor Google es sieht

Tool 1: Google Rich Results Test (Pflicht)

URL: search.google.com/test/rich-results

Das offizielle Google-Tool zeigt dir ob dein Schema Rich Results erzeugen kann. Wichtig: Es prüft nicht nur die JSON-Syntax, sondern ob Google die Seite auch so sieht wie du sie siehst (JavaScript-Rendering inklusive).

Was du siehst:

  • ✅ "Erkannte Rich Results" — dein Schema ist gültig und qualifiziert sich
  • ⚠️ "Erkannt mit Warnungen" — funktioniert, aber empfohlene Felder fehlen
  • ❌ "Fehler" — ungültiges Schema, kein Rich Result möglich

Tool 2: Schema.org Validator

URL: validator.schema.org

Dieser Validator prüft gegen die vollständige Schema.org Spezifikation — strenger als Google, nützlich für edge cases und proprietäre Schema-Typen.

Tool 3: Direkt in PHP validieren

Für automatisierte Checks in deiner CI/CD-Pipeline:

<?php
function validateSchemaJson(string $schemaJson): array {
    $errors = [];

    $decoded = json_decode($schemaJson, true);
    if (json_last_error() !== JSON_ERROR_NONE) {
        $errors[] = 'Ungültiges JSON: ' . json_last_error_msg();
        return $errors;
    }

    // Pflichtfelder prüfen
    if (empty($decoded['@context'])) {
        $errors[] = '@context fehlt (muss "https://schema.org" sein)';
    }
    if (empty($decoded['@type'])) {
        $errors[] = '@type fehlt';
    }

    // Typ-spezifische Pflichtfelder
    if ($decoded['@type'] === 'BlogPosting') {
        foreach (['headline', 'author', 'datePublished'] as $field) {
            if (empty($decoded[$field])) {
                $errors[] = "BlogPosting: Pflichtfeld '$field' fehlt";
            }
        }
        if (!empty($decoded['headline']) && mb_strlen($decoded['headline']) > 110) {
            $errors[] = 'BlogPosting: headline sollte unter 110 Zeichen sein (aktuell: '
                . mb_strlen($decoded['headline']) . ')';
        }
    }

    return $errors;
}

// Verwendung:
$schema = generateArticleSchema($post, 'https://deine-domain.de');
// JSON aus dem Script-Tag extrahieren:
preg_match('/<script type="application\/ld\+json">(.*?)<\/script>/s', $schema, $m);
$errors = validateSchemaJson($m[1] ?? '');

if (!empty($errors)) {
    error_log('Schema-Validierungsfehler: ' . implode(', ', $errors));
}

Die 7 häufigsten Fehler im Rich Result Test

Fehler 1: "Fehlende erforderliche Eigenschaft 'image'"

Tritt bei BlogPosting, Article und Product auf. Google verlangt für Rich Results zwingend ein Bild.

// Falsch: Kein Fallback wenn cover_image leer
'image' => $post['cover_image']

// Richtig: Immer ein Bild bereitstellen
'image' => [
    '@type'  => 'ImageObject',
    'url'    => !empty($post['cover_image'])
                    ? $post['cover_image']
                    : 'https://deine-domain.de/img/og-default.png',
    'width'  => 1200,
    'height' => 630,
],

Fehler 2: "Ungültiges Datumsformat"

// Falsch — PHP default date format
'datePublished' => date('Y-m-d', strtotime($post['published_at']))
// Gibt: "2026-05-06" — fehlt die Uhrzeit und Zeitzone

// Richtig — ISO 8601 mit Zeitzone
'datePublished' => (new \DateTime($post['published_at']))->format(\DateTime::ATOM)
// Gibt: "2026-05-06T10:00:00+02:00"

Fehler 3: "Das Element stimmt nicht mit dem Seiteninhalt überein" (FAQPage)

Google prüft ob die Fragen aus dem Schema auch als sichtbarer Text auf der Seite vorhanden sind. Schema-Only ohne HTML-Pendant wird abgestraft.

<!-- Schema allein reicht nicht -->
<!-- Die Fragen MÜSSEN auch als HTML auf der Seite stehen: -->
<section class="faq">
    <h2>Häufige Fragen</h2>
    <details>
        <summary>Was ist OPcache?</summary>
        <p>OPcache ist Phps eingebauter Bytecode-Cache...</p>
    </details>
</section>

Fehler 4: HTML in Schema-Feldern

// Falsch — HTML-Tags in JSON-LD
'text' => '<p>OPcache ist <strong>PHPs Bytecode-Cache</strong>.</p>'

// Richtig — Plain Text
'text' => strip_tags('OPcache ist PHPs Bytecode-Cache.')

Fehler 5: Relative URLs statt absolute URLs

// Falsch — relative URL
'url' => '/artikel/mein-artikel/'

// Richtig — absolute URL
'url' => 'https://deine-domain.de/artikel/mein-artikel/'

Fehler 6: Mehrere Schema-Typen falsch verschachtelt

<!-- Falsch: Zwei separate Script-Tags für dasselbe Objekt -->
<script type="application/ld+json">{"@type": "BlogPosting", ...}</script>
<script type="application/ld+json">{"@type": "BreadcrumbList", ...}</script>

<!-- Richtig: Ein @graph mit mehreren Typen ODER zwei separate Tags (beide sind korrekt)
     Empfohlen für mehrere Typen: @graph -->
<script type="application/ld+json">
{
  "@context": "https://schema.org",
  "@graph": [
    {
      "@type": "BlogPosting",
      "@id": "https://deine-domain.de/artikel/mein-artikel/#article",
      "headline": "..."
    },
    {
      "@type": "BreadcrumbList",
      "@id": "https://deine-domain.de/artikel/mein-artikel/#breadcrumb",
      "itemListElement": [...]
    }
  ]
}
</script>

Fehler 7: publisher fehlt bei Article

Google's Dokumentation markiert publisher als empfohlen (nicht Pflicht) — aber ohne es gibt es kein Top-Stories-Karussell und keinen Discover-Feed-Eintrag. Immer mitschicken.

Alles zusammen — die universelle PHP Schema-Klasse

<?php

class SchemaMarkup {
    private string $baseUrl;
    private array  $schemas = [];

    public function __construct(string $baseUrl) {
        $this->baseUrl = rtrim($baseUrl, '/');
    }

    public function addBlogPosting(array $post): self {
        $this->schemas[] = [
            '@type'    => 'BlogPosting',
            '@id'      => $this->baseUrl . '/artikel/' . $post['slug'] . '/#article',
            'headline' => mb_substr(strip_tags($post['title']), 0, 110),
            'description'   => strip_tags($post['excerpt'] ?? ''),
            'datePublished' => (new \DateTime($post['published_at']))->format(\DateTime::ATOM),
            'dateModified'  => (new \DateTime($post['updated_at'] ?? $post['published_at']))->format(\DateTime::ATOM),
            'image' => [
                '@type'  => 'ImageObject',
                'url'    => !empty($post['cover_image'])
                                ? (str_starts_with($post['cover_image'], 'http')
                                    ? $post['cover_image']
                                    : $this->baseUrl . $post['cover_image'])
                                : $this->baseUrl . '/img/og-default.png',
                'width'  => 1200,
                'height' => 630,
            ],
            'author' => [
                '@type' => 'Person',
                '@id'   => $this->baseUrl . '/user/' . urlencode($post['author_username']) . '/#person',
                'name'  => $post['author_name'],
                'url'   => $this->baseUrl . '/user/' . urlencode($post['author_username']) . '/',
            ],
            'publisher' => $this->getPublisher(),
            'mainEntityOfPage' => [
                '@type' => 'WebPage',
                '@id'   => $this->baseUrl . '/artikel/' . $post['slug'] . '/',
            ],
        ];
        return $this;
    }

    public function addBreadcrumbs(array $crumbs): self {
        $this->schemas[] = [
            '@type' => 'BreadcrumbList',
            '@id'   => $this->baseUrl . '/#breadcrumb',
            'itemListElement' => array_map(fn($crumb, $i) => [
                '@type'    => 'ListItem',
                'position' => $i + 1,
                'name'     => $crumb['name'],
                'item'     => str_starts_with($crumb['url'], 'http')
                                ? $crumb['url']
                                : $this->baseUrl . $crumb['url'],
            ], $crumbs, array_keys($crumbs)),
        ];
        return $this;
    }

    public function addFAQ(array $faqs): self {
        $this->schemas[] = [
            '@type' => 'FAQPage',
            'mainEntity' => array_map(fn($faq) => [
                '@type' => 'Question',
                'name'  => strip_tags($faq['question']),
                'acceptedAnswer' => [
                    '@type' => 'Answer',
                    'text'  => strip_tags($faq['answer']),
                ],
            ], array_slice($faqs, 0, 10)),
        ];
        return $this;
    }

    public function render(): string {
        if (empty($this->schemas)) {
            return '';
        }

        $payload = count($this->schemas) === 1
            ? array_merge(['@context' => 'https://schema.org'], $this->schemas[0])
            : ['@context' => 'https://schema.org', '@graph' => $this->schemas];

        return '<script type="application/ld+json">'
            . json_encode($payload, JSON_UNESCAPED_SLASHES | JSON_UNESCAPED_UNICODE | JSON_PRETTY_PRINT)
            . '</script>';
    }

    private function getPublisher(): array {
        return [
            '@type' => 'Organization',
            '@id'   => $this->baseUrl . '/#organization',
            'name'  => '3ernert.com',
            'url'   => $this->baseUrl,
            'logo'  => [
                '@type'  => 'ImageObject',
                'url'    => $this->baseUrl . '/img/logo.png',
                'width'  => 200,
                'height' => 60,
            ],
        ];
    }
}

// Verwendung in article.php:
$schema = (new SchemaMarkup('https://deine-domain.de'))
    ->addBlogPosting($post)
    ->addBreadcrumbs([
        ['name' => 'Home',  'url' => '/'],
        ['name' => 'Blog',  'url' => '/blog'],
        ['name' => $post['title'], 'url' => '/artikel/' . $post['slug'] . '/'],
    ])
    ->render();

echo $schema;

Die Schema-Checkliste für jede Seite

Startseite:
✅ WebSite (mit SearchAction für Sitelinks-Searchbox)
✅ Organization (mit Logo, sameAs Social Profiles)

Blog-Übersicht:
✅ BreadcrumbList
✅ WebPage

Blog-Artikel:
✅ BlogPosting (headline, author, datePublished, image, publisher)
✅ BreadcrumbList
✅ FAQPage (wenn FAQs vorhanden)

Service-Seite:
✅ ProfessionalService (mit areaServed, hasOfferCatalog)
✅ BreadcrumbList

Tutorial/Anleitung:
✅ HowTo (mit steps und totalTime)
✅ BreadcrumbList

Fazit: Schema ist kein Bonus — es ist Pflicht

In 2026 ist Schema Markup kein optionaler SEO-Trick mehr. Es ist die Sprache in der du mit Google kommunizierst. Seiten ohne strukturierte Daten konkurrieren mit Seiten die Google auf einen Blick alles erklären — Author, Datum, Inhalt, Typ, Bewertungen.

Die Implementierung dauert pro Seitentyp 30–60 Minuten. Der ROI ist messbar: mehr SERP-Fläche, höhere CTR, schnelleres Indexieren neuer Inhalte.

Fange mit BlogPosting und BreadcrumbList an — das sind die beiden Typen die auf jeder Seite mit Artikeln sofort Wirkung zeigen. Alles andere baut darauf auf.

*Welche Schema-Typen nutzt du bereits, und wo hast du die größten Verbesserungen gesehen? Schreib es in die Kommentare.

Teilen
X

Geschrieben von

XimenesBenz

Autor & Webentwickler bei 3ernert.com

Zurück zur Artikel-Übersicht

Das könnte dich auch interessieren

Maßgeschneiderter Code vs. Standard-CMS

Maßgeschneiderter Code vs. Standard-CMS

Die Entscheidung für eine neue Webseite oder einen Onlineshop beginnt meist mit einem verlockenden Versprechen: „Mit diesem Baukasten sind Sie in wenigen Stunden online!“ Systeme wie WordPress, Shopify oder Wix dominieren den Markt. Sie sind günstig und schnell aufgesetzt. Doch was für den kleinen Hobby-Blog perfekt ist, wird für ein wachsendes Unternehmen schnell zum unsichtbaren Flaschenhals. Warum eine maßgeschneiderte Eigenentwicklung langfristig die sicherere, schnellere und profitablere Entscheidung ist.

25.06.2026 Lesen
HTML5 Komplett-Tutorial: Der moderne Standard für das Web

HTML5 Komplett-Tutorial: Der moderne Standard für das Web

HTML5 ist weit mehr als eine bloße Aktualisierung der HyperText Markup Language. Seit die WHATWG (Web Hypertext Application Technology Working Group) das Modell des "Living Standard" etabliert hat, fungiert HTML5 als das dynamische Rückgrat des World Wide Web.

24.06.2026 Lesen

PHP vs Python vs JavaScript/Node.js (Webentwicklung/Backend)

PHP, Python oder Node.js? Wir vergleichen Performance, Architektur und Einsatzgebiete für Ihre Webentwicklung, um die richtige Wahl zu treffen.

16.06.2026 Lesen

Kommentare (0)

Diskutiere mit!

Logge dich ein oder erstelle kostenlos ein Konto, um an der Unterhaltung teilzunehmen und dein Wissen zu teilen.

Zum Login Konto erstellen

Noch keine Kommentare vorhanden. Sei der Erste!

Insider-Newsletter

Keine Trends mehr verpassen.

Exklusive Guides, neue Tools und Web-Strategien — handverlesen und direkt in dein Postfach. Kein Spam, jederzeit abbestellbar.

100 % Spam-frei
Max. 1× / Monat
Jederzeit kündbar