E-Mail bei der Registrierung validieren

import requests

API_KEY  = "YOUR_API_KEY"
response = requests.get(
    "https://api.veille.io/v1/email",
    headers={"x-api-key": API_KEY},
    params={"email": "[email protected]"},
)
result = response.json()
print(result)

const API_KEY = "YOUR_API_KEY";

const params   = new URLSearchParams({ email: "[email protected]" });
const response = await fetch(`https://api.veille.io/v1/email?${params}`, {
  headers: { "x-api-key": API_KEY },
});
const result = await response.json();
console.log(result);

<?php
$apiKey = "YOUR_API_KEY";
$params = http_build_query(["email" => "[email protected]"]);

$ch = curl_init("https://api.veille.io/v1/email?{$params}");
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_HTTPHEADER, ["x-api-key: {$apiKey}"]);
$result = json_decode(curl_exec($ch), true);
curl_close($ch);
print_r($result);

package main

import (
    "encoding/json"
    "fmt"
    "io"
    "net/http"
    "net/url"
)

func main() {
    params := url.Values{"email": {"[email protected]"}}
    req, _ := http.NewRequest("GET", "https://api.veille.io/v1/email?"+params.Encode(), nil)
    req.Header.Set("x-api-key", "YOUR_API_KEY")

    resp, _ := http.DefaultClient.Do(req)
    defer resp.Body.Close()
    body, _ := io.ReadAll(resp.Body)

    var result map[string]any
    json.Unmarshal(body, &result)
    fmt.Println(result)
}

import java.net.URI;
import java.net.URLEncoder;
import java.net.http.*;
import java.nio.charset.StandardCharsets;

var client  = HttpClient.newHttpClient();
var email   = URLEncoder.encode("[email protected]", StandardCharsets.UTF_8);
var request = HttpRequest.newBuilder()
    .uri(URI.create("https://api.veille.io/v1/email?email=" + email))
    .header("x-api-key", "YOUR_API_KEY")
    .GET().build();

var response = client.send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

using System.Net.Http;

using var client = new HttpClient();
client.DefaultRequestHeaders.Add("x-api-key", "YOUR_API_KEY");

var email = Uri.EscapeDataString("[email protected]");
var body  = await client.GetStringAsync($"https://api.veille.io/v1/email?email={email}");
Console.WriteLine(body);

#[tokio::main]
async fn main() -> Result<(), reqwest::Error> {
    let result = reqwest::Client::new()
        .get("https://api.veille.io/v1/email")
        .header("x-api-key", "YOUR_API_KEY")
        .query(&[("email", "[email protected]")])
        .send().await?.json::<serde_json::Value>().await?;

    println!("{:#?}", result);
    Ok(())
}

print(f"Gültig       : {result['is_valid']}")
print(f"Zustellbar   : {result['is_deliverable']}")
print(f"Wegwerf-Mail : {result['is_disposable']}")
print(f"Rollenkonto  : {result['is_role_account']}")
print(f"Risiko-Score : {result['risk_score']}/100")
if result.get("did_you_mean"):
    print(f"Meinten Sie  : {result['did_you_mean']}?")

console.log(`Gültig       : ${result.is_valid}`);
console.log(`Zustellbar   : ${result.is_deliverable}`);
console.log(`Wegwerf-Mail : ${result.is_disposable}`);
console.log(`Rollenkonto  : ${result.is_role_account}`);
console.log(`Risiko-Score : ${result.risk_score}/100`);
if (result.did_you_mean) console.log(`Meinten Sie  : ${result.did_you_mean}?`);

echo "Gültig       : " . ($result["is_valid"]       ? "true" : "false") . "\n";
echo "Zustellbar   : " . ($result["is_deliverable"]  ? "true" : "false") . "\n";
echo "Wegwerf-Mail : " . ($result["is_disposable"]   ? "true" : "false") . "\n";
echo "Risiko-Score : {$result['risk_score']}/100\n";
if (!empty($result["did_you_mean"])) echo "Meinten Sie  : {$result['did_you_mean']}?\n";

fmt.Printf("Gültig       : %v\nZustellbar   : %v\nWegwerf-Mail : %v\nRisiko-Score : %v/100\n",
    result["is_valid"], result["is_deliverable"], result["is_disposable"], result["risk_score"])
if typo, ok := result["did_you_mean"].(string); ok && typo != "" {
    fmt.Println("Meinten Sie  :", typo+"?")
}

import org.json.*;

var r = new JSONObject(response.body());
System.out.printf("Gültig       : %b%nZustellbar   : %b%nWegwerf-Mail : %b%nRisiko-Score : %d/100%n",
    r.getBoolean("is_valid"), r.getBoolean("is_deliverable"),
    r.getBoolean("is_disposable"), r.getInt("risk_score"));
if (r.has("did_you_mean")) System.out.println("Meinten Sie  : " + r.getString("did_you_mean") + "?");

using System.Text.Json;

var r = JsonDocument.Parse(body).RootElement;
Console.WriteLine($"Gültig       : {r.GetProperty("is_valid").GetBoolean()}");
Console.WriteLine($"Zustellbar   : {r.GetProperty("is_deliverable").GetBoolean()}");
Console.WriteLine($"Wegwerf-Mail : {r.GetProperty("is_disposable").GetBoolean()}");
Console.WriteLine($"Risiko-Score : {r.GetProperty("risk_score").GetInt32()}/100");
if (r.TryGetProperty("did_you_mean", out var typo) && typo.GetString() is { } t and not "")
    Console.WriteLine($"Meinten Sie  : {t}?");

println!("Gültig       : {}", result["is_valid"]);
println!("Zustellbar   : {}", result["is_deliverable"]);
println!("Wegwerf-Mail : {}", result["is_disposable"]);
println!("Risiko-Score : {}/100", result["risk_score"]);
if let Some(typo) = result["did_you_mean"].as_str() {
    if !typo.is_empty() { println!("Meinten Sie  : {}?", typo); }
}

import requests

API_KEY = "YOUR_API_KEY"

def validate_email(email: str) -> dict:
    r = requests.get("https://api.veille.io/v1/email",
        headers={"x-api-key": API_KEY}, params={"email": email})
    return r.json()

def register(email: str) -> dict:
    v = validate_email(email)

    if not v.get("is_valid"):
        return {"ok": False, "error": "Diese E-Mail-Adresse ist ungültig."}

    if v.get("is_disposable"):
        return {"ok": False, "error": "Temporäre E-Mail-Adressen werden nicht akzeptiert."}

    if v.get("did_you_mean"):
        return {"ok": False, "suggestion": f"Meinten Sie {v['did_you_mean']}?"}

    if v.get("risk_score", 0) >= 70:
        return {"ok": False, "error": "Hoher Risiko-Score. Bitte verwenden Sie eine andere Adresse."}

    if v.get("is_role_account"):
        return {"ok": True, "flag": "role_account", "message": "Bitte bestätigen Sie Ihre E-Mail."}

    return {"ok": True, "message": "Registrierung erfolgreich!"}

for test_email in ["[email protected]", "[email protected]", "[email protected]", "[email protected]"]:
    print(f"{test_email}: {register(test_email)}")

const API_KEY = "YOUR_API_KEY";

async function validateEmail(email: string) {
  const params = new URLSearchParams({ email });
  const res    = await fetch(`https://api.veille.io/v1/email?${params}`, {
    headers: { "x-api-key": API_KEY },
  });
  return res.json();
}

async function register(email: string) {
  const v = await validateEmail(email);
  if (!v.is_valid)       return { ok: false, error: "Ungültige E-Mail-Adresse." };
  if (v.is_disposable)   return { ok: false, error: "Temporäre E-Mails nicht akzeptiert." };
  if (v.did_you_mean)    return { ok: false, suggestion: `Meinten Sie ${v.did_you_mean}?` };
  if (v.risk_score >= 70) return { ok: false, error: "Hoher Risiko-Score — bitte andere Adresse verwenden." };
  if (v.is_role_account) return { ok: true,  flag: "role_account", message: "Bitte bestätigen Sie Ihre E-Mail." };
  return { ok: true, message: "Registrierung erfolgreich!" };
}

for (const email of ["[email protected]", "[email protected]", "[email protected]", "[email protected]"]) {
  console.log(email, await register(email));
}

<?php
function validateEmail(string $apiKey, string $email): array {
    $params = http_build_query(["email" => $email]);
    $ch = curl_init("https://api.veille.io/v1/email?{$params}");
    curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
    curl_setopt($ch, CURLOPT_HTTPHEADER, ["x-api-key: {$apiKey}"]);
    $result = json_decode(curl_exec($ch), true);
    curl_close($ch);
    return $result;
}

function register(string $apiKey, string $email): array {
    $v = validateEmail($apiKey, $email);
    if (!($v["is_valid"]      ?? false)) return ["ok" => false, "error" => "Ungültige E-Mail."];
    if ($v["is_disposable"]   ?? false)  return ["ok" => false, "error" => "Temporäre E-Mails nicht akzeptiert."];
    if (!empty($v["did_you_mean"]))      return ["ok" => false, "suggestion" => "Meinten Sie {$v['did_you_mean']}?"];
    if (($v["risk_score"]     ?? 0) >= 70) return ["ok" => false, "error" => "Hoher Risiko-Score."];
    if ($v["is_role_account"] ?? false)  return ["ok" => true,  "flag" => "role_account"];
    return ["ok" => true, "message" => "Registrierung erfolgreich!"];
}

foreach (["[email protected]", "[email protected]", "[email protected]"] as $email) {
    print_r(["email" => $email, "result" => register("YOUR_API_KEY", $email)]);
}

package main

import (
    "encoding/json"
    "fmt"
    "io"
    "net/http"
    "net/url"
)

const APIKey = "YOUR_API_KEY"

func validate(email string) map[string]any {
    params := url.Values{"email": {email}}
    req, _ := http.NewRequest("GET", "https://api.veille.io/v1/email?"+params.Encode(), nil)
    req.Header.Set("x-api-key", APIKey)
    resp, _ := http.DefaultClient.Do(req)
    defer resp.Body.Close()
    body, _ := io.ReadAll(resp.Body)
    var v map[string]any
    json.Unmarshal(body, &v)
    return v
}

func register(email string) string {
    v := validate(email)
    if !(v["is_valid"].(bool))    { return "❌ Ungültige E-Mail." }
    if v["is_disposable"].(bool)  { return "❌ Temporäre E-Mail nicht akzeptiert." }
    if typo, ok := v["did_you_mean"].(string); ok && typo != "" {
        return "⚠️  Meinten Sie " + typo + "?"
    }
    if v["risk_score"].(float64) >= 70 { return "❌ Hoher Risiko-Score." }
    return "✅ Registrierung erfolgreich!"
}

func main() {
    for _, email := range []string{"[email protected]", "[email protected]", "[email protected]"} {
        fmt.Printf("%s: %s\n", email, register(email))
    }
}

import java.net.URI;
import java.net.URLEncoder;
import java.net.http.*;
import java.nio.charset.StandardCharsets;
import org.json.*;

public class Main {
    static HttpClient client = HttpClient.newHttpClient();
    static String API_KEY   = "YOUR_API_KEY";

    static JSONObject validate(String email) throws Exception {
        var encoded = URLEncoder.encode(email, StandardCharsets.UTF_8);
        var req     = HttpRequest.newBuilder()
            .uri(URI.create("https://api.veille.io/v1/email?email=" + encoded))
            .header("x-api-key", API_KEY).GET().build();
        var resp    = client.send(req, HttpResponse.BodyHandlers.ofString());
        return new JSONObject(resp.body());
    }

    static String register(String email) throws Exception {
        var v = validate(email);
        if (!v.getBoolean("is_valid"))      return "❌ Ungültige E-Mail.";
        if (v.getBoolean("is_disposable"))  return "❌ Temporäre E-Mail nicht akzeptiert.";
        if (v.has("did_you_mean"))          return "⚠️  Meinten Sie " + v.getString("did_you_mean") + "?";
        if (v.getInt("risk_score") >= 70)   return "❌ Hoher Risiko-Score.";
        return "✅ Registrierung erfolgreich!";
    }

    public static void main(String[] args) throws Exception {
        for (var email : new String[]{"[email protected]", "[email protected]", "[email protected]"}) {
            System.out.printf("%s: %s%n", email, register(email));
        }
    }
}

using System.Net.Http;
using System.Text.Json;

var apiKey = "YOUR_API_KEY";
using var client = new HttpClient();
client.DefaultRequestHeaders.Add("x-api-key", apiKey);

async Task<JsonElement> Validate(string email)
{
    var encoded = Uri.EscapeDataString(email);
    var body    = await client.GetStringAsync($"https://api.veille.io/v1/email?email={encoded}");
    return JsonDocument.Parse(body).RootElement;
}

async Task<string> Register(string email)
{
    var v = await Validate(email);
    if (!v.GetProperty("is_valid").GetBoolean())                      return "❌ Ungültige E-Mail.";
    if (v.GetProperty("is_disposable").GetBoolean())                  return "❌ Temporäre E-Mail nicht akzeptiert.";
    if (v.TryGetProperty("did_you_mean", out var t) && t.GetString() is { Length: > 0 } typo)
                                                                      return $"⚠️  Meinten Sie {typo}?";
    if (v.GetProperty("risk_score").GetInt32() >= 70)                 return "❌ Hoher Risiko-Score.";
    return "✅ Registrierung erfolgreich!";
}

foreach (var email in new[] { "[email protected]", "[email protected]", "[email protected]" })
    Console.WriteLine($"{email}: {await Register(email)}");

use reqwest::Client;
use serde_json::Value;

const API_KEY: &str = "YOUR_API_KEY";

async fn validate(client: &Client, email: &str) -> Value {
    client.get("https://api.veille.io/v1/email")
        .header("x-api-key", API_KEY)
        .query(&[("email", email)])
        .send().await.unwrap().json::<Value>().await.unwrap()
}

async fn register(client: &Client, email: &str) -> &'static str {
    let v = validate(client, email).await;
    if !v["is_valid"].as_bool().unwrap_or(false)     { return "❌ Ungültige E-Mail."; }
    if  v["is_disposable"].as_bool().unwrap_or(false) { return "❌ Temporäre E-Mail nicht akzeptiert."; }
    if  v["risk_score"].as_i64().unwrap_or(0) >= 70  { return "❌ Hoher Risiko-Score."; }
    "✅ Registrierung erfolgreich!"
}

#[tokio::main]
async fn main() -> Result<(), reqwest::Error> {
    let client = Client::new();
    for email in ["[email protected]", "[email protected]", "[email protected]"] {
        println!("{}: {}", email, register(&client, email).await);
    }
    Ok(())
}