WordPress-Kontaktformulare im Jahr 2026: Zustellbarkeit, Spam-Schutz und CRM

Wenn Ihr Kontaktformular nicht funktioniert, existiert Ihr Geschäft nicht.

Das klingt dramatisch, aber in vielen Dienstleistungsunternehmen ist das Formular der einzige Kanal, über den Vertriebsanfragen hereinkommen. Ob Sie Leads sammeln, Support-Anfragen bearbeiten oder Kunden um Feedback bitten: Das Formular bleibt das Rückgrat der Online-Kommunikation eines Unternehmens. Trotzdem verlassen sich die meisten WordPress-Websites auf die Standardkonfiguration von PHP mail(), die Leads direkt in den Spam-Ordner schickt, und Firmen verlieren dadurch jeden Monat Anfragen, von denen sie nicht einmal wissen.

Webformulare haben sich verändert. KI-gestützte Bots kommen mit herkömmlichen CAPTCHA-Systemen inzwischen zurecht. Datenschutzgesetze wie die DSGVO in der EU und der CCPA in Kalifornien haben verändert, wie wir Nutzerdaten erheben und speichern. Nutzer wiederum erwarten einfache Formulare, die jeden Schritt klar erklären und ohne überflüssige Etappen durch eine komplexere Anfrage führen.

Die eigentliche Arbeit beginnt jenseits von “Contact Form 7 installieren”. Ob eine Einsendung ankommt, hängt von der Wahl des Form-Builders ab, von einer korrekten SMTP-Konfiguration, davon, Spam einzudämmen, ohne echte Menschen auszusperren, von der Einhaltung der Einwilligungsregeln und von der Messung der Stellen, an denen Einsendungen verloren gehen.

Bei der Website eines kleinen Unternehmens, einer Enterprise-Plattform und einem Headless-WordPress ist das Ziel dasselbe: Das Formular muss so zuverlässig sein, dass jede gültige Anfrage im richtigen Prozess landet. Mehr zur Absicherung der gesamten Website lesen Sie bei unserem WordPress-Sicherheitsaudit.

#Wie man SMTP für WordPress-Kontaktformulare einrichtet

Der Hauptgrund, warum Formulare versagen, ist die Zustellbarkeit. Nicht das Design und nicht der Text, sondern die Zustellung der Nachricht. Hosting-Server (Shared Hosting, VPS, Cloud) haben eine schwache IP-Reputation, weil Tausende Websites dieselben Adressen nutzen und ein Teil davon Spam versendet. Wenn Sie eine E-Mail von [email protected] über die native PHP-Funktion mail() verschicken, vertrauen Gmail und Outlook ihr so sehr wie dem Brief eines nigerianischen Prinzen.

#Warum PHP mail() im Jahr 2026 scheitert

Die Funktion mail() versendet Nachrichten ohne Authentifizierung, ohne korrekte Header und ohne Verwaltung der Absenderreputation. Heutige E-Mail-Anbieter filtern Nachrichten und prüfen dabei unter anderem:

• SPF (Sender Policy Framework): ob der sendende Server berechtigt ist, im Namen der Domain zu versenden
• DKIM (DomainKeys Identified Mail): eine kryptografische Signatur, die bestätigt, dass der Inhalt nicht verändert wurde
• DMARC (Domain-based Message Authentication): eine Richtlinie, was mit Nachrichten geschehen soll, die SPF oder DKIM nicht bestehen
• IP-Reputation: den Versandverlauf der jeweiligen Adresse
• Inhaltsanalyse: typische Spam-Begriffe, Qualität der Links, Formatierung

Ohne eine korrekte SMTP-Konfiguration landen Formulareinsendungen im Spam oder werden vollständig abgewiesen.

#Welchen SMTP-Anbieter man für WordPress wählt

Sie brauchen einen externen SMTP-Anbieter mit gefestigter Reputation und Unterstützung der Authentifizierungsprotokolle. Hier sind die am häufigsten genutzten Optionen für WordPress im Jahr 2026.

#Gmail und Google Workspace SMTP

Für wen: kleine Unternehmen, die Google Workspace bereits nutzen

Einrichtung:

1. Aktivieren Sie die Bestätigung in zwei Schritten im Google-Konto
2. Erzeugen Sie ein App-Passwort unter myaccount.google.com/apppasswords
3. Tragen Sie in FluentSMTP ein:
   • Host: smtp.gmail.com
   • Port: 587 (TLS) oder 465 (SSL)
   • Authentifizierung: ja
   • Benutzername: vollständige E-Mail-Adresse
   • Passwort: das 16-stellige App-Passwort

Einschränkungen: Google nennt ein Tageslimit von 2.000 Nachrichten pro Workspace-Nutzer und 500 für Testkonten (Gmail-Sendelimits in Google Workspace)

#SendGrid

Für wen: hohe Versandvolumen, Marketing-Integrationen

Einrichtung:

1. Konto auf sendgrid.com anlegen
2. Einen API-Key mit der Berechtigung “Mail Send” erzeugen
3. FluentSMTP per API (empfohlen) oder per SMTP konfigurieren:
   • API-Methode: API-Key einfügen
   • SMTP-Methode:
     • Host: smtp.sendgrid.net
     • Port: 587
     • Benutzername: apikey
     • Passwort: Ihr SendGrid-API-Key

Vorteile: Zustellbarkeitsanalysen, Event Webhook zur Verfolgung von Bounces und Öffnungen

#Mailgun

Für wen: Entwickler, API-basierte Anwendungen

Einrichtung:

1. Auf mailgun.com registrieren und die Domain verifizieren
2. Die von Mailgun angegebenen DNS-Einträge setzen (MX sowie TXT für SPF und DKIM)
3. In FluentSMTP eintragen:
   • Host: smtp.mailgun.org
   • Port: 587
   • Benutzername: [email protected]
   • Passwort: SMTP-Passwort aus dem Mailgun-Dashboard

Vorteile: kostenloser Tarif mit einem Limit von 100 E-Mails pro Tag (Mailgun-Preise, Oktober 2026), API, detaillierte Logs

#Postmark

Für wen: Transaktions-Mails, höchste Zustellbarkeit

Einrichtung:

1. Konto auf postmarkapp.com anlegen
2. Die Absendersignatur verifizieren (Domain oder Adresse)
3. Einen Server API Token erzeugen
4. In FluentSMTP die Verbindung per API wählen:
   • als Anbieter “Postmark” angeben
   • den Server API Token einfügen

Vorteile: 100 E-Mails pro Monat im kostenlosen Entwicklertarif, standardmäßig 45 Tage vollständiger Inhaltsverlauf, Bounce-Verwaltung (Postmark-Preise)

#Amazon SES (Simple Email Service)

Für wen: große Unternehmen und Absender mit hohem Volumen bei kleinem Budget

Einrichtung:

1. AWS-Konto anlegen und die SES-Konsole öffnen
2. Die Domain verifizieren und Produktionszugang beantragen (hebt die Grenzen des Sandbox-Modus auf)
3. SMTP-Zugangsdaten in der SES-Konsole im Bereich SMTP Settings erzeugen
4. In FluentSMTP eintragen:
   • Host: email-smtp.us-east-1.amazonaws.com (abhängig von der Region)
   • Port: 587 (TLS) oder 2587 (TLS)
   • Benutzername: SMTP-Benutzername aus SES
   • Passwort: SMTP-Passwort aus SES

Vorteile: 0,10 USD pro 1.000 ausgehende E-Mails im Tarif ohne Plan (“à la carte”, Amazon-SES-Preise), skaliert auf Millionen Nachrichten, integriert sich in den Rest von AWS

#Wie man FluentSMTP einrichtet

FluentSMTP ist 2026 der einfachste Weg zu SMTP in WordPress:

• Kostenlos und Open Source: Es gibt keine Bezahlversion (über 700.000 aktive Installationen auf wordpress.org, Oktober 2026)
• Mehrere Anbieter: mehrere SMTP-Verbindungen mit Failover
• Integration per API: API-Keys statt SMTP-Zugangsdaten, schneller und sicherer
• Versandprotokolle: integriertes Dashboard mit gesendeten und fehlgeschlagenen Nachrichten
• Routing-Regeln: verschiedene Formulare können über verschiedene Anbieter versenden

Installation:

wp plugin install fluent-smtp --activate

#Wie man fehlgeschlagene WordPress-E-Mails debuggt

Wenn das Formular abgeschickt wird, die Nachrichten aber nicht ankommen, ergänzen Sie diesen Diagnosecode:

// Log all email failures for debugging
add_action( 'wp_mail_failed', function( $error ) {
    error_log( 'Email Failure: ' . print_r( $error, true ) );
} );

// Log successful sends (for verification)
add_action( 'wp_mail_succeeded', function( $mail_data ) {
    error_log( 'Email Sent: ' . implode( ', ', (array) $mail_data['to'] ) );
} );

Die Fehlerprotokolle prüfen Sie so:

tail -f /var/log/apache2/error.log
tail -f /var/log/nginx/error.log
# Or use WP-CLI
wp shell
>>> error_log( 'Test email logging' );

#Vergleich der WordPress-Formular-Plugins

Die Wahl des Form-Builders beeinflusst alles, vom Komfort für Nutzer bis zur Freiheit für Entwickler. Der folgende Vergleich stützt sich auf die Plugin-Seiten im Verzeichnis von wordpress.org und die Preisliste von Gravity Forms.

#1. Contact Form 7

Preis: kostenlos

Vorteile:

• Vollständig kostenlos, ohne Premium-Version, über 10 Millionen aktive Installationen auf wordpress.org (Oktober 2026)
• Integrierte Anbindung an Akismet, reCAPTCHA und Cloudflare Turnstile
• Praktisch beliebig erweiterbar über Hooks und Filter
• Entwicklerfreundlich (reines HTML und Shortcodes)
• Riesiges Ökosystem an Erweiterungen
• Schlank bei richtiger Konfiguration

Nachteile:

• Lädt seine Assets standardmäßig auf jeder Seite (Kosten für die Performance)
• Kein visueller Builder, HTML-Kenntnisse nötig
• Keine integrierte Speicherung von Einsendungen (das übernimmt das separate Plugin Flamingo)
• Keine bedingte Logik ohne Erweiterungen
• Sehr schlichtes Standard-Design

Für wen: Entwickler, die volle Kontrolle wollen, einfache Kontaktformulare

Performance-Optimierung:

// Only load CF7 assets on pages with forms
add_filter( 'wpcf7_load_js', '__return_false' );
add_filter( 'wpcf7_load_css', '__return_false' );

// Then manually enqueue on specific pages
function my_cf7_scripts() {
    if ( is_page( 'kontakt' ) ) {
        wpcf7_enqueue_scripts();
        wpcf7_enqueue_styles();
    }
}
add_action( 'wp_enqueue_scripts', 'my_cf7_scripts' );

#2. Gravity Forms

Preis: 59 USD pro Jahr (Basic, 1 Website), 159 USD pro Jahr (Pro, 3 Websites), 259 USD pro Jahr (Elite, unbegrenzte Websites) laut Preisliste von Gravity Forms vom Oktober 2026

Vorteile:

• Werkzeuge für Formulare nach WCAG 2.1 AA, eingeführt mit Version 2.5
• Native Add-ons (Stripe, HubSpot, Zapier; Salesforce nur in der Elite-Lizenz)
• Umfangreiche bedingte Logik
• Mehrstufige Formulare mit Fortschrittsanzeige
• Integrierte Verwaltung und Export von Einsendungen
• Datei-Uploads
• Add-on Signature für Unterschriften

Nachteile:

• Teure Jahreslizenz
• Kann Shared Hosting belasten
• Die fortgeschrittenen Funktionen erfordern Einarbeitung

Für wen: Unternehmenswebsites, komplexe Formulare, Anforderungen an Barrierefreiheit

#3. WPForms

Preis: kostenlose Version WPForms Lite (über 5 Millionen aktive Installationen auf wordpress.org, Oktober 2026) sowie kostenpflichtige Lizenzen

Vorteile:

• Drag-and-drop-Builder mit Live-Vorschau
• Über 2.100 fertige Formularvorlagen laut Plugin-Seite auf wordpress.org
• Konversationsformulare (im Stil von Typeform)
• Integrierter Spamschutz (Honeypot und CAPTCHA)
• Verwaltung der Einsendungen im WordPress-Dashboard
• Add-on Form Abandonment (Speicherung teilweise ausgefüllter Formulare)
• Registrierungs- und Login-Formulare

Nachteile:

• Mehrseitige Formulare, Datei-Uploads und bedingte Logik sind Pro-Funktionen
• Add-ons erfordern höhere Lizenzen
• Weniger entwicklerfreundlich als Gravity Forms

Für wen: Einsteiger, kleine Unternehmen, schnelle Umsetzungen

#4. Fluent Forms

Preis: kostenlos (über 800.000 aktive Installationen auf wordpress.org, Oktober 2026) sowie Pro-Lizenzen

Vorteile:

• Weniger als 30 KB CSS und JS zusammen für ein Standardformular laut Plugin-Seite auf wordpress.org
• Integrierte Konversationsformulare
• Bedingte Logik, DSGVO-Zustimmungsfeld (GDPR Agreement) und Turnstile-Feld in der kostenlosen Version
• Über 60 Integrationen mit externen Diensten in der Pro-Version
• PDF-Erzeugung
• Quiz-Punktevergabe
• Sehr gute Performance

Nachteile:

• Kleineres Ökosystem als Gravity Forms
• Mehrstufige Formulare, Datei-Uploads und automatisches Löschen von Einträgen erfordern Pro

Für wen: Websites, bei denen Performance zählt, moderne WordPress-Stacks

#5. Formidable Forms

Preis: kostenlos (über 300.000 aktive Installationen auf wordpress.org, Oktober 2026) sowie kostenpflichtige Tarife

Vorteile:

• Integrierte Datenansichten und Ausgabe von Einsendungen auf der Website
• Möglichkeit, einfache Anwendungen zu bauen
• Berechnete Felder und komplexe Mathematik
• Visual Views (Einsendungen als Verzeichnisse und Listen)
• Produktkonfigurator für WooCommerce
• API-Webhooks

Nachteile:

• Höhere Einstiegshürde
• Die Oberfläche wirkt älter als bei der Konkurrenz

Für wen: datengestützte Anwendungen, Verzeichnisse, Rechner

#6. Headless-Formulare mit Next.js und Astro

Bei einem Headless-WordPress rendert das Plugin das Formular nicht im Frontend, weil das Frontend kein WordPress-Theme ist. Sie bauen das Formular in Next.js oder Astro und senden die Daten per POST-Request an den REST-Endpunkt von Contact Form 7: POST /wp-json/contact-form-7/v1/contact-forms/{id}/feedback. Validierung und Spamregeln laufen weiterhin auf der WordPress-Seite, Sie müssen sie im Frontend also nicht doppeln.

#Vergleichstabelle der WordPress-Formular-Plugins

Funktionsaufteilung laut den Plugin-Seiten auf wordpress.org und der Preisliste von Gravity Forms, Oktober 2026.

#Wie man Spam im Kontaktformular ohne CAPTCHA stoppt

Im Jahr 2026 kommen KI-Bots besser zurecht als reCAPTCHA v3. Sie bewegen sich durch Formulare, klicken Checkboxen an, lösen Bilderrätsel und versenden überzeugenden Spam mit “SEO-Dienstleistungen”. Klassische CAPTCHAs erschweren echten Nutzern das Leben und stoppen fortgeschrittenere Angriffe trotzdem nicht.

#Honeypot, Turnstile, Akismet und Validierung auf dem Server

#1. Honeypot-Feld

Ein verstecktes Feld, das nur Bots ausfüllen. Ein Mensch sieht es nicht und lässt es leer. Ein Bot füllt jedes Feld aus, das er findet.

Umsetzung:

<!-- Add to your form -->
<div style="position: absolute; left: -5000px;" aria-hidden="true">
    <input type="text" name="website" tabindex="-1" value="">
</div>

Validierung auf dem Server:

add_filter( 'wpcf7_validate', function( $result, $tags ) {
    if ( ! empty( $_POST['website'] ) ) {
        $result->invalidate( '', 'Spam erkannt.' );
    }
    return $result;
}, 10, 2 );

Die meisten modernen Form-Builder haben ein Honeypot-Feld standardmäßig; prüfen Sie nur, ob es aktiviert ist.

Einen Praxisfall beschreibt elszczepano am 19. August 2026. Ein WordPress-Blog schützte seine Kommentare mit Akismet und reCAPTCHA, bis reCAPTCHA zu Google Cloud umzog. Dort ist ein Konto mit eingerichteter Abrechnung nötig, und das kostenlose Kontingent ist begrenzt. Der Autor wechselte zu Cloudflare Turnstile. Laut der Statistik von Cloudflare galt etwa die Hälfte der Zugriffe auf die Website als wahrscheinlicher Bot, trotzdem lagen nach einigen Wochen mehrere hundert Kommentare im Spam-Ordner. Geholfen hat erst ein verstecktes Feld im Kommentarformular, das in der Anfrage vorhanden und leer sein muss, eingebunden in der functions.php über die Action comment_form und den Filter preprocess_comment. Seit November 2025 ist laut Autor kein einziger Kommentar mehr im Spam-Ordner gelandet.

#2. Cloudflare Turnstile

Eine nutzerfreundliche Alternative zu CAPTCHAs. Ohne Rätsel und ohne Kästchen “Ich bin kein Roboter”. Turnstile nutzt Browsersignale und JavaScript-Challenges, die für den Nutzer unsichtbar sind.

Einrichtung:

1. Konto auf cloudflare.com anlegen (es gibt einen kostenlosen Tarif)
2. Site Key und Secret Key im Turnstile-Dashboard abrufen
3. Das Plugin “Simple Cloudflare Turnstile” installieren oder das Widget manuell einbinden

Einbindung:

<!-- Add to form head -->
<script src="https://challenges.cloudflare.com/turnstile/v0/api.js" async defer></script>

<!-- Add before submit button -->
<div class="cf-turnstile" data-sitekey="YOUR_SITE_KEY"></div>

Was die Dokumentation sagt:

• Drei Widget-Modi: verwaltet (zeigt das Kästchen nur Besuchern mit höherem Risiko), nicht interaktiv und unsichtbar (Turnstile-Übersicht)
• Der kostenlose Tarif erlaubt bis zu 20 Widgets und unbegrenzt viele Challenges (Turnstile-Tarife)
• Das Widget allein beweist nichts: “Sie müssen die Siteverify-API aufrufen, um Ihre Turnstile-Implementierung abzuschließen” (Cloudflare-Dokumentation, eigene Übersetzung). Jedes Token gilt 300 Sekunden und lässt sich nur einmal validieren
• Contact Form 7 hat ein natives Tag [turnstile], Fluent Forms ein Turnstile-Feld; ein separates Plugin ist also optional

#3. Integration von Akismet

Akismet entstand zum Filtern von Kommentaren in WordPress, sein maschinelles Lernen erkennt aber auch Spam in Formularen gut.

Einrichtung:

1. Das Plugin Akismet installieren
2. Einen API-Key holen: Der persönliche Tarif funktioniert nach dem Prinzip “zahle, was du kannst”, kommerzielle Websites brauchen den Pro- oder Business-Tarif (Akismet-Preise)
3. Die Akismet-Filterung im Form-Builder aktivieren (in Contact Form 7 ergänzen Sie Optionen wie akismet:author und akismet:author_email an den Tags für Name und E-Mail)

Integration in Gravity Forms:

• Formulareinstellungen und den Bereich Akismet öffnen
• Die Option für den Schutz des Formulars durch Akismet aktivieren
• Festlegen, was mit Spam geschieht (abweisen oder zur Prüfung markieren)

#4. Eigene Validierung auf dem Server

Ergänzen Sie Prüfungen, die zu den Bedrohungen passen, die Sie in Ihren Einsendungen tatsächlich sehen:

// Block submissions from specific countries (use with caution)
add_filter( 'wpcf7_validate', function( $result, $tags ) {
    $blocked_countries = [ 'XX', 'YY' ]; // Country codes
    $country = $_SERVER['HTTP_CF_IPCOUNTRY'] ?? '';

    if ( in_array( $country, $blocked_countries ) ) {
        $result->invalidate( '', 'Einsendungen aus Ihrer Region werden nicht angenommen.' );
    }
    return $result;
}, 10, 2 );

// Rate limiting by IP
function check_form_rate_limit() {
    $ip = $_SERVER['REMOTE_ADDR'];
    $transient = 'form_submit_' . md5( $ip );
    $count = get_transient( $transient ) ?: 0;

    if ( $count > 5 ) {
        wp_die( 'Zu viele Einsendungen. Bitte versuchen Sie es später erneut.' );
    }

    set_transient( $transient, $count + 1, HOUR_IN_SECONDS );
}
add_action( 'wpcf7_before_send_mail', 'check_form_rate_limit' );

// Block submissions with URLs in name fields
add_filter( 'wpcf7_validate_text', function( $result, $tag ) {
    $field_name = $tag->name;
    $value = isset( $_POST[$field_name] ) ? $_POST[$field_name] : '';

    if ( preg_match( '/http|www|\.com|\.net/i', $value ) ) {
        $result->invalidate( $tag, 'URLs sind in diesem Feld nicht erlaubt.' );
    }
    return $result;
}, 10, 2 );

#5. Validierung der Ausfüllzeit

Bots senden das Formular sofort ab, ein Mensch braucht einen Moment. Die Zeit vom Laden des Formulars bis zum Absenden messen Sie in JavaScript:

// Add to your form page
document.addEventListener('DOMContentLoaded', function() {
    const form = document.querySelector('.wpcf7-form');
    const startTime = Date.now();

    form.addEventListener('submit', function(e) {
        const elapsed = Date.now() - startTime;

        if (elapsed < 3000) { // Less than 3 seconds
            e.preventDefault();
            alert('Bitte nehmen Sie sich Zeit zum Ausfüllen des Formulars.');
        }
    });
});

#DSGVO-konformes Kontaktformular in WordPress

Wer Einsendungen sammelt, verarbeitet personenbezogene Daten. Die DSGVO in der EU, der CCPA in Kalifornien und ähnliche Vorschriften weltweit stellen hier konkrete Anforderungen. Ein Kontaktformular braucht nicht automatisch eine Einwilligung: Sie ist nur eine von sechs Rechtsgrundlagen in Art. 6 DSGVO. Die Beantwortung einer Anfrage stützt sich meist auf Buchstabe b, die Verarbeitung “zur Durchführung vorvertraglicher Maßnahmen […], die auf Anfrage der betroffenen Person erfolgen”, oder auf Buchstabe f, berechtigte Interessen. Die Einwilligung wird erst dann zur Grundlage, wenn Sie etwas wollen, das die Anfrage selbst nicht erfordert, etwa eine Newsletter-Anmeldung.

#Was die DSGVO von einem WordPress-Kontaktformular verlangt

#1. Einwilligungs-Checkboxen

Wo die Einwilligung die Grundlage ist (Newsletter, Marketing-Kontakt), muss die Checkbox:

• Standardmäßig leer sein: Erwägungsgrund 32 der DSGVO hält fest: “Stillschweigen, bereits angekreuzte Kästchen oder Untätigkeit der betroffenen Person sollten daher keine Einwilligung darstellen.”
• Getrennt sein: eine eigene Einwilligung pro Zweck (Marketing separat, Kontakt separat)
• Konkret sein: klar beschreiben, wozu der Nutzer einwilligt
• Dokumentiert sein: Art. 7 Abs. 1 verlangt, dass der Verantwortliche die Einwilligung nachweisen kann; speichern Sie also Datum und Version des Formulars
• Widerrufbar sein: Art. 7 Abs. 3: “Der Widerruf der Einwilligung muss so einfach wie die Erteilung der Einwilligung sein.”

Beispielhafte Umsetzung:

<label>
    <input type="checkbox" name="privacy_consent" required>
    Ich habe die <a href="/de/datenschutzrichtlinie-und-impressum/">Datenschutzerklärung</a> gelesen.
    <span class="required">*</span>
</label>

<label>
    <input type="checkbox" name="marketing_consent">
    Ich bin damit einverstanden, Marketinginformationen zu erhalten (optional).
</label>

Umsetzung in Gravity Forms:

• Ein Feld vom Typ “Consent” hinzufügen
• Die Seite mit der Datenschutzerklärung verlinken
• Die Einwilligung wird in den Daten der Einsendung gespeichert und lässt sich später nachweisen

#2. Regeln für die Datenaufbewahrung

Bewahren Sie Einsendungen nicht unbegrenzt auf. Richten Sie eine automatische Löschung ein:

Gravity Forms: Formulareinstellungen, Reiter Personal Data, Retention Policy: Einsendungen nach einer festgelegten Zahl von Tagen in den Papierkorb verschieben oder löschen, dazu die Option, das Speichern von IP-Adressen abzuschalten (Dokumentation) Fluent Forms: automatisches Löschen von Einträgen (Pro-Funktion) Contact Form 7: speichert standardmäßig nichts; wenn Sie Flamingo ergänzen, müssen Sie dessen Einträge selbst bereinigen

Eigene Umsetzung:

// Auto-delete entries older than 90 days
function cleanup_old_form_entries() {
    global $wpdb;

    $wpdb->query( "
        DELETE FROM {$wpdb->prefix}gf_entry
        WHERE date_created < DATE_SUB(NOW(), INTERVAL 90 DAY)
        AND status = 'active'
    " );
}
add_action( 'wp_scheduled_delete', 'cleanup_old_form_entries' );

#3. Recht auf Löschung (Recht auf Vergessenwerden)

Nutzer können die Löschung ihrer Daten verlangen. Formulare müssen das abbilden:

• Ein Formular “Meine Daten löschen” bereitstellen
• Innerhalb eines Monats nach Eingang des Antrags antworten; bei komplexen Fällen lässt sich die Frist um weitere zwei Monate verlängern (Art. 12 Abs. 3 DSGVO)
• Die Daten aus den Einsendungen, dem CRM, den E-Mail-Logs und den Backups entfernen
• Löschungen für Audits dokumentieren

Umsetzung:

// Data deletion endpoint
add_action( 'wp_ajax_request_data_deletion', function() {
    $email = sanitize_email( $_POST['email'] );

    // Verify email exists in entries
    // Delete from all form tables
    // Delete from CRM (via API)
    // Send confirmation email

    wp_send_json_success( 'Ihre Daten wurden gelöscht.' );
});

#4. Verträge zur Auftragsverarbeitung (AVV)

SMTP-Anbieter und CRM-Systeme verarbeiten die Formulardaten in Ihrem Auftrag, daher verlangt Art. 28 DSGVO einen Vertrag mit jedem von ihnen. Prüfen Sie, ob sie einen AVV bereitstellen; SendGrid, Mailgun, Postmark, HubSpot und Salesforce bieten eigene Vertragswerke zur Datenverarbeitung an. Bewahren Sie die unterzeichneten Verträge für den Fall einer Prüfung auf.

#5. Datenschutz durch Technikgestaltung

Begrenzen Sie die Datenerhebung von Anfang an:

• Nur die Felder erheben, die Sie wirklich brauchen
• Pseudonymisierung einsetzen, wo es möglich ist
• Sensible Felder in der Datenbank verschlüsseln
• Den Zugriff von Administratoren auf Einsendungen beschränken

#Wie man ein mehrstufiges Formular in WordPress baut

Ein Formular mit 10 gleichzeitig sichtbaren Feldern schreckt ab. Mehrstufige Formulare zerlegen eine komplexe Anfrage in kleinere Teile.

Logik der Schritte:

• Schritt 1: “Was ist Ihr Ziel?” (geringe Reibung, leichte Antwort)
• Schritt 2: “Welches Budget haben Sie?” (mittlere Reibung)
• Schritt 3: “Name und E-Mail” (hohe Reibung, aber der Nutzer ist bereits eingebunden)

Die oft zitierten 300 % stammen aus dem Text einer Agentur über ihre eigene Website, nicht aus einer unabhängigen Studie. Behandeln Sie die Zahl als einen einzelnen Datenpunkt. Wie groß die Verbesserung ausfällt, hängt von Ihrem Formular ab, also messen Sie sie selbst.

#Mehrstufige Formulare in Gravity Forms, WPForms und Fluent Forms

#Gravity Forms

1. Felder vom Typ “Page” hinzufügen, um das Formular in Schritte zu teilen
2. Die Fortschrittsanzeige einstellen (Balken, Schritte, Prozent)
3. “Save and Continue” bei langen Formularen aktivieren
4. Bedingte Logik nutzen, um irrelevante Schritte zu überspringen

Tipps:

• Den Fortschritt zeigen: “Schritt 2 von 4”
• Abschnittsüberschriften sollen an den Nutzen erinnern, z. B. “Fast geschafft”
• Das Speichern von Teil-Einsendungen aktivieren, um Personen zurückzugewinnen, die abgebrochen haben

#WPForms

1. Das Add-on “Form Pages” (Pro) installieren
2. Den Modus “Conversational Forms” aktivieren
3. Ein Layout wählen (modern oder klassisch)
4. Farben und Branding einstellen

#Fluent Forms

Mehrstufige Formulare sind eine Pro-Funktion (Feld “Form Step”):

1. Dem Formular das Feld “Form Step” hinzufügen
2. Die Felder per Drag-and-drop den einzelnen Schritten zuordnen
3. Titel und Beschreibungen der Schritte festlegen
4. Den Navigationsstil wählen (Pfeile, Punkte, Fortschrittsbalken)

#Wie man die Konversion eines Kontaktformulars steigert

#1. Reihenfolge der Felder

Die leichtesten Felder kommen an den Anfang:

1. Schritt 1: Ziel oder Interesse (Dropdown oder Auswahlbuttons)
2. Schritt 2: Projektdetails (Textfeld)
3. Schritt 3: Zeitrahmen oder Budget (Auswahlliste)
4. Schritt 4: Kontaktdaten (Name, E-Mail, Telefon)

#2. Sinnvolle Standardwerte

Füllen Sie Informationen vor, die Sie bereits kennen:

// Pre-fill from URL parameters
document.addEventListener('DOMContentLoaded', function() {
    const urlParams = new URLSearchParams(window.location.search);
    const source = urlParams.get('utm_source');

    if (source) {
        document.querySelector('input[name="source"]').value = source;
    }
});

#3. Validierung während des Ausfüllens

Prüfen Sie Felder, sobald der Nutzer sie verlässt, nicht erst beim Absenden:

// Real-time email validation
document.querySelector('input[type="email"]').addEventListener('blur', function() {
    const email = this.value;
    const regex = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;

    if (!regex.test(email)) {
        this.classList.add('error');
        this.nextElementSibling.textContent = 'Bitte geben Sie eine gültige E-Mail-Adresse ein';
    }
});

#4. Optimierung für Mobilgeräte

• Große Touch-Ziele (mindestens 44x44 px)
• Zifferntastatur für Telefon- und Postleitzahlfelder
• Datumsauswahl statt Textfeldern
• Tests der Bedienung mit dem Daumen

#Wie man ein WordPress-Formular mit HubSpot und anderen CRMs verbindet

Formulardaten nur per E-Mail zu verschicken, verschenkt eine Gelegenheit. Eine direkte CRM-Integration startet die nächsten Schritte sofort und beseitigt Fehler beim manuellen Übertragen der Daten.

#Wie man Formulareinsendungen an HubSpot sendet

Gravity Forms: offizielles HubSpot-Add-on

• Zuordnung der Formularfelder zu HubSpot-Eigenschaften
• Automatisches Anlegen von Kontakten, Unternehmen und Deals
• Datenanreicherung über HubSpot Insights
• Auslösen von Workflows nach dem Absenden

WPForms: HubSpot-Add-on (kostenpflichtige Lizenz)

• Synchronisierung in Echtzeit
• Zuordnung eigener Eigenschaften
• Anlegen von Deals aus Formulardaten

Fluent Forms: HubSpot-Integration in der Pro-Version

• Anlegen von Kontakten mit Feldzuordnung

Manuelle Integration (für Entwickler):

add_action( 'gform_after_submission', function( $entry, $form ) {
    $api_key = 'your-hubspot-api-key';
    $endpoint = 'https://api.hubapi.com/crm/v3/objects/contacts';

    $data = [
        'properties' => [
            'email' => $entry['1'],
            'firstname' => $entry['2.3'],
            'lastname' => $entry['2.6'],
            'company' => $entry['3'],
            'message' => $entry['4'],
            'source' => 'Website Contact Form'
        ]
    ];

    wp_remote_post( $endpoint, [
        'headers' => [
            'Authorization' => 'Bearer ' . $api_key,
            'Content-Type' => 'application/json'
        ],
        'body' => json_encode( $data )
    ]);
}, 10, 2 );

#Wie man Formulareinsendungen an Salesforce sendet

Gravity Forms: Salesforce-Add-on

• Zuordnung zu Leads, Contacts oder eigenen Objekten
• Anlegen von Kampagnenmitgliedern
• Unterstützung für Anhänge

Formidable Forms: Salesforce-Konnektor

• Synchronisierung in beide Richtungen
• Komplexe Beziehungen zwischen Objekten
• Validierung in Echtzeit

WPForms: braucht Zapier als Vermittler

#Wie man Formulareinsendungen an Zoho CRM sendet

Fluent Forms: Integration mit Zoho CRM (Pro)

• Anlegen von Kontakten und Leads
• Zuweisen von Aufgaben
• Unterstützung eigener Module

Gravity Forms: über Zapier oder einen eigenen Webhook

#Wie man Formulareinsendungen an Pipedrive sendet

Gravity Forms: über Zapier

• Anlegen von Personen und Deals
• Zuordnung einer Phase in der Pipeline
• Zuordnung eigener Felder

Fluent Forms: Integration per Webhook

#Wie man ein beliebiges CRM über Zapier anbindet

Fehlt eine native Integration, verbindet Zapier das Formular mit über 9.000 Anwendungen (Zapier-App-Verzeichnis, Oktober 2026):

1. Ein Zapier-Konto anlegen
2. Das Absenden des Formulars als Auslöser festlegen
3. Das CRM als Aktion wählen
4. Die Felder zwischen den Systemen zuordnen

Vorteile:

• Kein Code nötig
• Bedingte Logik (“Deal nur anlegen, wenn das Budget 1000 USD übersteigt”)
• Mehrstufige Zaps (Formular, dann CRM, dann Benachrichtigung in Slack, dann Kalender)

#Wie man Formulareinsendungen in GA4 erfasst

Ohne Analyse arbeiten Sie im Blindflug. Messen Sie die Leistung Ihrer Formulare, um die Stellen zu finden, an denen Nutzer aufgeben, und das, was sich verbessern lässt.

#GA4-Ereignisse für Beginn und Absenden des Formulars

Ereignis-Tracking:

// Track form starts
document.querySelector('form').addEventListener('focusin', function() {
    gtag('event', 'form_start', {
        'form_name': 'contact_form',
        'page_location': window.location.pathname
    });
}, { once: true });

// Track form submissions
document.addEventListener('wpcf7mailsent', function(event) {
    gtag('event', 'form_submit', {
        'form_name': 'contact_form',
        'form_id': event.detail.contactFormId
    });
});

// Track form errors
document.addEventListener('wpcf7invalid', function(event) {
    gtag('event', 'form_error', {
        'form_name': 'contact_form',
        'error_count': event.detail.apiResponse.invalidFields.length
    });
});

Konversionsziele:

1. In GA4 Verwaltung öffnen, dann Ereignisse, dann Ereignis erstellen
2. form_submit als Schlüsselereignis markieren (so nennt GA4 heute Conversions)
3. Einen Wert festlegen (optional): den durchschnittlichen Deal-Wert von Leads aus dem Formular

Die Einbindung des Tags selbst beschreiben wir im Leitfaden Google Analytics 4 zu WordPress hinzufügen.

#Wie man Leads aus dem Formular mit dem Meta Pixel erfasst

document.addEventListener('wpcf7mailsent', function() {
    fbq('track', 'Lead', {
        content_name: 'Contact Form',
        value: 50.00,
        currency: 'USD'
    });
});

#Integrierte Auswertungen in Gravity Forms, WPForms und Fluent Forms

#Gravity Forms

Die Formularliste zeigt für jedes Formular:

• Aufrufe
• Einsendungen
• Konversionsrate (Einsendungen im Verhältnis zu Aufrufen)

#WPForms

• Anzahl der Einsendungen und Trends im Dashboard
• Teil-Einsendungen über das Add-on Form Abandonment (Pro)

#Fluent Forms

• Formularanalyse und visueller Datenbericht (kostenlos)
• Geolokalisierungsanbieter (Pro)
• Export der Einsendungen als CSV, Excel, ODS oder JSON (kostenlos)

#Heatmaps für Kontaktformulare

Microsoft Clarity (kostenlos) oder Hotjar zeigen:

• Wo Nutzer zögern
• Welche Felder Probleme bereiten
• Unterschiede im Verhalten zwischen Mobilgerät und Desktop

#Bedingte Logik in WordPress-Formularen

Bedingte Logik blendet Felder abhängig von den Antworten des Nutzers ein oder aus, sodass sich das Formular an die jeweilige Person anpasst.

#Beispiele für bedingte Logik in WordPress-Formularen

#1. Felder ein- und ausblenden

WENN "Art der Anfrage" = "Support"
DANN Liste "Support-Kategorie" anzeigen
SONST ausblenden

Gravity Forms:

• Feld bearbeiten, Reiter Conditional Logic
• Regeln vom Typ anzeigen oder ausblenden, wenn [Feld] [Operator] [Wert]
• Mehrere Bedingungen mit AND und OR verknüpfen

Fluent Forms:

• Feldeinstellungen, Conditional Logic
• Visueller Regel-Builder
• Unterstützung komplexer, verschachtelter Bedingungen

#2. Felder dynamisch befüllen

Füllen Sie Felder aus URL-Parametern, Benutzer-Metadaten oder der Datenbank:

// Populate from URL: ?service=web-design
add_filter( 'gform_field_value_service', function( $value ) {
    return sanitize_text_field( $_GET['service'] ?? '' );
});

// Populate from user meta (for logged-in users)
add_filter( 'gform_field_value_user_company', function( $value ) {
    $user = wp_get_current_user();
    return get_user_meta( $user->ID, 'company', true );
});

#3. Berechnete Felder

Angebote, Rechner und Punktevergabe:

Formidable Forms (am besten für Berechnungen):

[quantity] * [unit_price] + [tax]

Gravity Forms:

• Feld Number, Option Enable Calculation
• Merge-Tags: {Field 1:3} * {Field 2:4}

#4. Datei-Uploads mit Einschränkungen

// Custom validation for uploads
add_filter( 'gform_validation', function( $validation_result ) {
    $form = $validation_result['form'];

    foreach ( $form['fields'] as &$field ) {
        if ( $field->type == 'fileupload' ) {
            $file = $_FILES[ 'input_' . $field->id ];

            // Limit to 5MB
            if ( $file['size'] > 5 * 1024 * 1024 ) {
                $validation_result['is_valid'] = false;
                $field->failed_validation = true;
                $field->validation_message = 'Die Datei muss kleiner als 5 MB sein';
            }

            // Virus scan (if ClamAV available)
            // exec( 'clamscan ' . escapeshellarg( $file['tmp_name'] ) );
        }
    }

    return $validation_result;
});

#5. Beiträge aus dem Formular erstellen

Lassen Sie Nutzer Inhalte einreichen (Bewertungen, Anzeigen, Gastbeiträge):

Gravity Forms + Advanced Post Creation:

• Zuordnung der Felder zu Titel, Inhalt und Auszug des Beitrags
• Festlegen des Status (Entwurf oder ausstehende Prüfung)
• Dynamisches Zuweisen von Kategorien
• Hochladen eines Beitragsbilds

#Wie man ein Kontaktformular in WordPress beschleunigt

Nicht optimierte Formulare können die Core Web Vitals deutlich verschlechtern. So halten Sie die Reaktionszeit auf Interaktionen im grünen Bereich: Als “gut” gilt eine Interaction to Next Paint (INP) von höchstens 200 ms (web.dev).

#Wie man das Laden von CSS und JavaScript des Formulars optimiert

#1. Bedingtes Laden der Assets

Laden Sie die Formular-Skripte nicht auf jeder Seite:

// Disable CF7 assets globally
add_filter( 'wpcf7_load_js', '__return_false' );
add_filter( 'wpcf7_load_css', '__return_false' );

// Load only on specific pages
function load_form_assets() {
    if ( is_page( [ 'kontakt', 'angebot', 'support' ] ) ) {
        if ( function_exists( 'wpcf7_enqueue_scripts' ) ) {
            wpcf7_enqueue_scripts();
            wpcf7_enqueue_styles();
        }
    }
}
add_action( 'wp_enqueue_scripts', 'load_form_assets' );

#2. Skripte verzögern

Verzögern Sie Formular-Skripte, die nicht kritisch sind:

function defer_form_scripts( $tag, $handle ) {
    $defer_handles = [ 'contact-form-7', 'gravityforms' ];

    if ( in_array( $handle, $defer_handles ) ) {
        return str_replace( ' src=', ' defer src=', $tag );
    }

    return $tag;
}
add_filter( 'script_loader_tag', 'defer_form_scripts', 10, 2 );

#3. CSS-Optimierung

Das kritische CSS des Formulars inline einbinden, den Rest später laden:

function inline_critical_form_css() {
    if ( ! is_page( 'kontakt' ) ) return;

    $css = file_get_contents( get_template_directory() . '/assets/css/forms-critical.css' );
    echo '<style>' . wp_strip_all_tags( $css ) . '</style>';
}
add_action( 'wp_head', 'inline_critical_form_css' );

#Wie man die Speicherung von Einsendungen in der Datenbank begrenzt

#1. Limit für gespeicherte Einsendungen

Einsendungen belegen Platz in der Datenbank. Führen Sie eine Rotation ein:

// Keep only last 1000 entries per form
function limit_form_entries( $entry_id, $form_id ) {
    global $wpdb;

    $table = $wpdb->prefix . 'gf_entry';
    $count = $wpdb->get_var( "SELECT COUNT(*) FROM $table WHERE form_id = $form_id" );

    if ( $count > 1000 ) {
        $wpdb->query( "
            DELETE FROM $table
            WHERE form_id = $form_id
            ORDER BY date_created ASC
            LIMIT " . ( $count - 1000 )
        );
    }
}
add_action( 'gform_after_submission', 'limit_form_entries', 10, 2 );

#2. Speicherung bei einfachen Formularen abschalten

Wenn Ihnen die Benachrichtigung per E-Mail genügt:

Gravity Forms: Formulareinstellungen, Speicherung der Einsendungen abschalten Fluent Forms: Formulareinstellungen, Speichern der Einsendungen abschalten

#Wie man Formularseiten vom Cache ausnimmt

Seiten mit Formularen sollten nicht im Cache landen:

# Nginx - Exclude forms from cache
location ~* (kontakt|angebot|formular) {
    set $skip_cache 1;
}

# .htaccess - Exclude forms from cache
<IfModule mod_rewrite.c>
RewriteCond %{REQUEST_URI} (kontakt|angebot|formular)
RewriteRule .* - [E=dont_cache:1]
</IfModule>

#Wie man den Cloudflare-Cache auf der Kontaktseite umgeht

Wenn Sie Cloudflare nutzen:

1. Eine Cache Rule anlegen (Page Rules sind der ältere Mechanismus), die auf den URI-Pfad /kontakt passt
2. Die Cache-Berechtigung auf “Bypass cache” setzen
3. Turnstile im Formular selbst belassen, dann ist eine zusätzliche Cloudflare-Challenge auf der ganzen Seite nicht nötig

#Dokumentation und Quellen zu WordPress-Formularen

#Offizielle Dokumentation

• Dokumentation von Contact Form 7
• Entwicklerdokumentation von Gravity Forms
• Wissensdatenbank von WPForms
• Dokumentation von Fluent Forms
• Einrichtungsanleitung für FluentSMTP

#E-Mail-Zustellbarkeit

• Google Postmaster Tools: Überwachung der Domain-Reputation
• Mail Tester: Test der Zustellbarkeit
• MXToolbox: Prüfung von DNS und Blocklisten

#Datenschutz

• Amtlicher Text der DSGVO auf EUR-Lex
• CCPA-Vorschriften

#Performance

• Leitfaden zu den Core Web Vitals
• Optimierung von WordPress in der Dokumentation

#Sicherheit

• OWASP Input Validation Cheat Sheet
• Dokumentation von Cloudflare Turnstile

#Was man sich zu Kontaktformularen merken sollte

Ein wirksames Kontaktformular in WordPress verbindet im Jahr 2026 vom ersten Tag an Zustellbarkeit, Spamschutz, Rechtskonformität und Messung:

1. Nie PHP mail() verwenden. Richten Sie SMTP mit einem transaktionalen E-Mail-Dienst ein.
2. Den Form-Builder passend wählen: zu Ihren technischen Fähigkeiten und den Anforderungen des Unternehmens.
3. Das Formular in Schichten schützen: Honeypot, Turnstile, Akismet und eigene Validierung.
4. DSGVO-Anforderungen umsetzen: passende Rechtsgrundlage, Einwilligungs-Checkboxen dort, wo sie nötig sind, Aufbewahrungsfristen und Verträge zur Auftragsverarbeitung.
5. Die Konversion verbessern: mit mehrstufigen Formularen, Validierung während des Ausfüllens und Gestaltung für Mobilgeräte.
6. Das CRM anbinden, um das manuelle Übertragen von Daten zu beenden und Automatisierung zu starten.
7. Alles messen: GA4-Ereignisse, Formularanalyse, Heatmaps.
8. Auf die Performance achten: durch bedingtes Laden der Assets und Ordnung in der Datenbank.

Das Formular ist der Händedruck zwischen Ihnen und Ihrem Kunden. Sorgen Sie dafür, dass er zuverlässig, sicher und freundlich ist.

Ein Formular ohne Validierung auf dem Server und ohne Anbindung an das CRM verliert Anfragen auf eine Weise, die niemand sofort bemerkt. Den gesamten Weg, vom Formularfeld bis zum Datensatz im System, setzen wir als WordPress-Entwickler um.