3. Verifizierung der CAPTCHA-Lösung

✅ Ein voll funktionsfähiges Backend-Beispiel finden Sie am Ende dieser Seite.

Serverseitige Verifizierung
Curl Beispiel
API-Antwort
Zusammenfassung der Antwort der POST-Anfrage
Vollständige Backend-Beispiele (PHP, Python, Node...)

Einfacher Wechsel

Die Überprüfung der Lösung (Token) funktioniert auf die gleiche Weise wie bei Google reCAPTCHA & hCaptcha. Nur die API-Antwort ist etwas anders und enthält mehr Informationen. Außerdem können Sie mit demselben API-Aufruf auch E-Mail-Adressen verifizieren.

Serverseitige Verifizierung

Erinnern Sie sich an den geheimen Schlüssel, der automatisch zusammen mit dem Sitekey generiert wurde. Dieser geheime Schlüssel wird benötigt, um die CAPTCHA-Lösung mit dem API-Endpunkt zu überprüfen und sicherzustellen, dass die Lösung (Token) tatsächlich echt und gültig ist.

Zur Überprüfung der CAPTCHA-Lösung senden Sie eine POST-Anfrage an

https://www.zencaptcha.com/captcha/siteverify

mit den folgenden Parametern:

Post Parameter	Beschreibung
response	Die Lösung (`zenc-captcha-solution`) des CAPTCHA
secret	Ihr `geheimer Schlüssel` (der mit dem Sitekey des Widgets übereinstimmt)
email	Optional: `E-Mail-Adresse` des Benutzers (Wegwerf-/Gültigkeitsprüfung) - Alternativ können Sie auch einfach den Domänennamen der E-Mail angeben (für maximalen Datenschutz: example.com).

Verwenden Sie POST

Nicht mit einer GET-Anfrage /siteverify aufrufen (sonst schlägt es fehl)

Curl Beispiel

Ändern Sie CAPTCHA-SOLUTION und GEHEIMER-SCHLÜSSEL-HIER-EINGEBEN mit Ihren Werten:

curl
curl https://www.zencaptcha.com/captcha/siteverify
-X POST 
-H "Content-Type: application/x-www-form-urlencoded" 
-d 'response=CAPTCHA-SOLUTION&secret=GEHEIMER-SCHLÜSSEL-HIER-EINGEBEN'

Um die Lösung (Token) zenc-captcha-solution zu verifizieren, das von Ihrem Frontend-HTML an Ihr Backend gesendet wird, benötigt der Endpunkt eine POST-Anfrage mit zwei Parametern - Ihrem geheimen Schlüssel und dem Token zenc-captcha-solution. Sie können optional die E-Mail-Adresse des Benutzers &email=xxx@example.com angeben, um zu prüfen, ob der Benutzer eine Wegwerf- oder ungültige E-Mail-Adresse verwendet. (Diese Option ist nur in allen kostenpflichtigen Paketen verfügbar).

API-Antwort

Die Antwort der Verifizierung

Die Antwort auf die POST-Anfrage zeigt an, ob die CAPTCHA-Lösung (Token) gültig ist.

Die Antwort ist ein JSON-Objekt.

Die Antwort enthält auch den Ländercode des Benutzers (ISO 3166-1 Alpha-2-Codes), die Gültigkeit der E-Mail-Adresse des Benutzers (sofern Sie diese auch übermittelt haben) und eine Betrugsbewertung für jeden Benutzer von 0 bis 99. Werte zwischen 0 und 55 sind akzeptabel, während Werte zwischen 55 und 99 darauf hinweisen, dass der Benutzer möglicherweise betrügerisch ist. Verlassen Sie sich nicht auf den Score, er soll Ihnen lediglich dabei helfen, potenziell betrügerische Benutzer anhand ihrer Aktivitäten auf Ihrer Website besser zu identifizieren oder frühzeitig Maßnahmen zu ergreifen.

json
{
    "success":true|false,  //true wenn die Validierung erfolgreich war
    "message":"XXX", // `valid` oder eine andere Fehlermeldung
    "fraudscore":XXX, //eine Zahl zwischen `0`-`99`
    "countrycode":"XXX", //Zweibuchstabiger Ländercode z.B. `DE`, `FR`
    "emailvalid":"XXX" /`none`, `valid_email`, `invalid_email`, `disposable_email` oder `upgrade_plan`
}
//"success":true und "message":"valid" Das bedeutet, dass die Lösung korrekt ist. => Benutzer akzeptieren

Gültigkeit der Lösung

Lösungen können nur einmal validiert werden und werden dann als ungültig oder dupliziert markiert. Lösungen sind auch nur bis zu 5 Minuten gültig, danach werden sie als ungültig markiert. Wenn Sie eine neue Lösung benötigen, sollten Sie das Captcha zurücksetzen (zencap.reset()) und es erneut starten (zencap.start()).

Zusammenfassung der Antwort der POST-Anfrage

Antwortschlüssel	Beschreibung
success	Wenn `true`, dann war die Lösung korrekt, das "message"-Feld muss nicht überprüft werden. Wenn `false`, dann war die Lösung ungültig, doppelt oder hat die Zeit überschritten mehr Infos in `message` .
message	Wenn `valid`, dann war die Lösung richtig. Wenn `"timeout_or_duplicate"`, dann wurde die Lösung bereits überprüft oder hat ein Zeitlimit überschritten. Wenn `"invalid_solution"`, dann ist die Lösung nicht gültig. Andere Fehlercodes sind möglich.
fraudscore	`0-55` ist akzeptabel, `55-99` bedeutet, dass der Benutzer ein Spammer sein könnte, basierend auf potentiellen betrügerischen Aktivitäten. Ein Wert von "0-55" bedeutet jedoch nicht, dass der Benutzer kein Spammer ist. Die Verwendung erfolgt auf eigene Gefahr.
countrycode	Zweibuchstabige Ländercodes der Benutzer, die in `ISO 3166-1 - (ISO 3166-1 alpha-2 codes)` definiert sind. Zum Beispiel: Deutschland `DE`, Frankreich `FR` usw.
emailvalid	`"valid_email"` ist perfekt, `"invalid_email"` oder `"disposable_email"` ist nicht gut. `"disposable_email"` bedeutet, dass der Benutzer versucht hat, eine Wegwerf-E-Mail-Adresse zu verwenden (100% sicher). `"none"` bedeutet, dass Sie womöglich keine E-Mail-Adresse übermittelt haben. `"upgrade_plan"` bedeutet, dass Sie ihren Plan aktualisieren müssen

Vollständige Backend-Beispiele

PHP
Node
Python
Ruby

PHP
$email = $_POST['email'];
$password = $_POST['password'];
$captcharesponse = $_POST['zenc-captcha-solution']; //Antwort des Captcha - die Lösung

$secret = "GEHEIMER-SCHLÜSSEL-HIER-EINGEBEN"; //Teilen Sie niemals Ihren Schlüssel öffentlich

$data = array(
    "response" => $captcharesponse,
    "secret" => $secret,
    "email" => $email, //Optional: E-Mail-Adresse des Benutzers
);

$options = array(
    "http" => array(
        "header" => "Content-type: application/x-www-form-urlencoded",
        "method" => "POST",
        "content" => http_build_query($data),
    ),
);

$context = stream_context_create($options);
$verify = file_get_contents("https://www.zencaptcha.com/captcha/siteverify", false, $context);
$captcha_success = json_decode($verify);

if ($captcha_success->success==false) {
    //falsche Lösung - nicht fortfahren
    exit();
}
else{
    //richtige Lösung - fahren Sie mit Ihrem Code fort
    //$captcha_success->fraudscore 
    //$captcha_success->countrycode
    //$captcha_success->emailvalid
}

Node
const https = require('https');
const querystring = require('querystring');

const postData = querystring.stringify({
  'response': 'zenc-captcha-solution', //Antwort des Captcha - die Lösung
  'secret': 'GEHEIMER-SCHLÜSSEL-HIER-EINGEBEN', //Teilen Sie niemals Ihren Schlüssel
  'email': 'USER-EMAIL-ADDRESS' //E-Mail-Adresse des Benutzers
});

const options = {
  hostname: 'www.zencaptcha.com',
  path: '/captcha/siteverify',
  method: 'POST',
  headers: {
    'Content-Type': 'application/x-www-form-urlencoded',
    'Content-Length': postData.length
  }
};

const req = https.request(options, (res) => {
  console.log(`statusCode: ${res.statusCode}`);

  let data = '';

  res.on('data', (chunk) => {
    data += chunk;
  });

  res.on('end', () => {
    const result = JSON.parse(data);
    if (result.success) {
      console.log('Verification successful! '+ result.message);
      //richtige Lösung - fahren Sie mit Ihrem Code fort
      //result.fraudscore (get the score)
      //result.countrycode (get users' country code)
      //result.emailvalid (check users' email address)
    } else {
      console.log('Verification failed. '+ result.message);
      return;
      //do not continue
    }
  });
});

req.on('error', (error) => {
  console.error(error);
});

req.write(postData);
req.end();

Python
import requests
import json

email = request.getParameter("email")  
password = request.getParameter("password") 
captcharesponse = request.getParameter("zenc-captcha-solution")
secret = "GEHEIMER-SCHLÜSSEL-HIER-EINGEBEN" #Teilen Sie niemals Ihren Schlüssel

data = {
    "response": captcharesponse, 
    "secret": secret,
    "email": email
}

url = "https://www.zencaptcha.com/captcha/siteverify"
response = requests.post(url, data=data)
verify = response.text
captcha_success = json.loads(verify)

if not captcha_success["success"]: 
    #falsche Lösung - nicht fortfahren
    return  
else:
    #richtige Lösung - fahren Sie mit Ihrem Code fort
    #captcha_success["fraudscore"]
    #captcha_success["countrycode"]
    #captcha_success["emailvalid"]

Ruby
require 'net/http'
require 'json'

email = get_parameter("email")  
password = get_parameter("password") 
captcharesponse = get_parameter("zenc-captcha-solution")
secret = "GEHEIMER-SCHLÜSSEL-HIER-EINGEBEN" #Teilen Sie niemals Ihren Schlüssel

data = {
    "response" => captcharesponse, 
    "secret" => secret,
    "email" => email 
}

url = URI("https://www.zencaptcha.com/captcha/siteverify")

http = Net::HTTP.new(url.host, url.port)
request = Net::HTTP::Post.new(url)
request["Content-Type"] = "application/x-www-form-urlencoded"
request.body = URI.encode_www_form(data)

response = http.request(request)
verify = response.read_body

captcha_success = JSON.parse(verify)

if not captcha_success["success"] 
    #wrong solution - do not continue
    return  
else
    #richtige Lösung - fahren Sie mit Ihrem Code fort
    #captcha_success["fraudscore"]
    #captcha_success["countrycode"]
    #captcha_success["emailvalid"]
end

3. Verifizierung der CAPTCHA-Lösung

Serverseitige Verifizierung​

Curl Beispiel​

API-Antwort​

Die Antwort der Verifizierung​

Zusammenfassung der Antwort der POST-Anfrage​

Vollständige Backend-Beispiele​