Automated meta tags and structured data validation setup

Automatic Meta Tags and Structured Data Validation

Meta tags and Schema.org markup affect how snippets appear in search results and how pages display in social networks. Automatic validation catches duplicate titles, empty descriptions, invalid JSON-LD, and missing OG tags before Google indexes the pages.

Validation Structure

Crawler → Playwright (JS render) → Meta tag parsing →
→ Rule validation → Per-page report → Alert on critical issues

Implementation

// scripts/meta-checker.ts
import { chromium, Browser, Page } from 'playwright';

interface MetaAudit {
  url:        string;
  title:      string | null;
  description: string | null;
  canonical:  string | null;
  robots:     string | null;
  og_title:   string | null;
  og_image:   string | null;
  og_desc:    string | null;
  twitter_card: string | null;
  schema_types: string[];
  schema_errors: string[];
  issues:     Issue[];
}

interface Issue {
  severity: 'critical' | 'warning' | 'info';
  rule:     string;
  message:  string;
}

async function auditPage(page: Page, url: string): Promise<MetaAudit> {
  await page.goto(url, { waitUntil: 'networkidle' });

  const meta = await page.evaluate(() => {
    const getMeta = (name: string) =>
      document.querySelector(`meta[name="${name}"]`)?.getAttribute('content') ||
      document.querySelector(`meta[property="${name}"]`)?.getAttribute('content') || null;

    // Parse JSON-LD
    const jsonldScripts = Array.from(document.querySelectorAll('script[type="application/ld+json"]'));
    const schemas: any[] = [];
    const schemaErrors: string[] = [];

    for (const script of jsonldScripts) {
      try {
        schemas.push(JSON.parse(script.textContent || ''));
      } catch (e) {
        schemaErrors.push(`Invalid JSON-LD: ${e.message}`);
      }
    }

    return {
      title:       document.title,
      description: getMeta('description'),
      canonical:   document.querySelector('link[rel="canonical"]')?.getAttribute('href') || null,
      robots:      getMeta('robots'),
      og_title:    getMeta('og:title'),
      og_image:    getMeta('og:image'),
      og_desc:     getMeta('og:description'),
      twitter_card: getMeta('twitter:card'),
      schema_types: schemas.map(s => s['@type']).filter(Boolean),
      schema_errors: schemaErrors,
    };
  });

  const issues: Issue[] = [];

  // Validation rules
  if (!meta.title) {
    issues.push({ severity: 'critical', rule: 'title-missing', message: 'Title is missing' });
  } else if (meta.title.length < 10) {
    issues.push({ severity: 'warning', rule: 'title-too-short', message: `Title too short: ${meta.title.length} characters` });
  } else if (meta.title.length > 70) {
    issues.push({ severity: 'warning', rule: 'title-too-long', message: `Title too long: ${meta.title.length} characters (max 70)` });
  }

  if (!meta.description) {
    issues.push({ severity: 'critical', rule: 'desc-missing', message: 'Meta description is missing' });
  } else if (meta.description.length > 160) {
    issues.push({ severity: 'warning', rule: 'desc-too-long', message: `Description too long: ${meta.description.length} characters` });
  }

  if (!meta.canonical) {
    issues.push({ severity: 'warning', rule: 'canonical-missing', message: 'Canonical URL is missing' });
  } else if (!meta.canonical.startsWith('https://')) {
    issues.push({ severity: 'warning', rule: 'canonical-http', message: 'Canonical uses HTTP instead of HTTPS' });
  }

  if (!meta.og_image) {
    issues.push({ severity: 'warning', rule: 'og-image-missing', message: 'og:image is missing' });
  }

  if (meta.schema_errors.length > 0) {
    meta.schema_errors.forEach(err =>
      issues.push({ severity: 'critical', rule: 'schema-invalid-json', message: err })
    );
  }

  return { url, ...meta, issues };
}

async function auditSite(urls: string[]): Promise<MetaAudit[]> {
  const browser = await chromium.launch({ headless: true });
  const results: MetaAudit[] = [];

  // Parallel, max 5 concurrent
  const BATCH = 5;
  for (let i = 0; i < urls.length; i += BATCH) {
    const batch = urls.slice(i, i + BATCH);
    const pages = await Promise.all(batch.map(() => browser.newPage()));

    const batchResults = await Promise.all(
      batch.map((url, j) => auditPage(pages[j], url))
    );
    results.push(...batchResults);
    await Promise.all(pages.map(p => p.close()));
  }

  await browser.close();
  return results;
}

Finding Duplicate Titles and Descriptions

function findDuplicates(audits: MetaAudit[]): { titles: Map<string, string[]>, descs: Map<string, string[]> } {
  const titleMap = new Map<string, string[]>();
  const descMap  = new Map<string, string[]>();

  for (const audit of audits) {
    if (audit.title) {
      const existing = titleMap.get(audit.title) || [];
      titleMap.set(audit.title, [...existing, audit.url]);
    }
    if (audit.description) {
      const existing = descMap.get(audit.description) || [];
      descMap.set(audit.description, [...existing, audit.url]);
    }
  }

  // Keep only duplicates
  return {
    titles: new Map([...titleMap].filter(([, urls]) => urls.length > 1)),
    descs:  new Map([...descMap].filter(([, urls]) => urls.length > 1)),
  };
}

Validating JSON-LD with Google Rich Results API

async function validateSchemaWithGoogle(url: string): Promise<any> {
  const apiUrl = `https://searchconsole.googleapis.com/v1/urlTestingTools/mobileFriendlyTest:run`;
  // Use Google Search Console API to check rich snippets
  // Alternative: schema.org validator
  const validator = await fetch(
    `https://validator.schema.org/validate?url=${encodeURIComponent(url)}&format=json`
  );
  return validator.json();
}

Timeframe

Automatic meta tag audit with JSON-LD validation and duplicate detection: 2–3 business days.