Domain bei der Registrierung validieren

Stellen Sie sicher, dass eine Domain real, aktiv und nicht in Betrugslisten eingetragen ist — mit der Veille Domain-Validierungs-API.

Übersicht

Dieses Playbook zeigt, wie Sie die Domain eines neuen Unternehmens validieren, das sich für Ihren SaaS-Dienst anmeldet: Überprüfung der Registrierung, DNS-Einträge und Reputations-Score. So verhindern Sie, dass gefälschte oder wegwerfbare Unternehmensdomänen Ihren Onboarding-Flow betreten.

Voraussetzungen

Einen Veille-API-Schlüssel — erhalten Sie einen auf app.veille.io
Installieren Sie die Abhängigkeiten für Ihre Sprache:

pip install requests

Keine zusätzlichen Abhängigkeiten — verwendet die native fetch-API (Node 18+).

curl-Erweiterung aktiviert (standardmäßig).

Keine zusätzlichen Abhängigkeiten — verwendet net/http (Go 1.18+).

Keine zusätzlichen Abhängigkeiten — verwendet java.net.http (Java 11+).

Keine zusätzlichen Abhängigkeiten — verwendet System.Net.Http (.NET 6+).

# Cargo.toml
[dependencies]
reqwest = { version = "0.12", features = ["json"] }
tokio = { version = "1", features = ["full"] }
serde_json = "1"

Schritte

Domain validieren

Rufen Sie GET /v1/domain mit dem Parameter domain auf.

import requests

API_KEY  = "YOUR_API_KEY"
response = requests.get(
    "https://api.veille.io/v1/domain",
    headers={"x-api-key": API_KEY},
    params={"domain": "acme-corp.com"},
)
result = response.json()
print(result)

const API_KEY = "YOUR_API_KEY";

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

<?php
$apiKey = "YOUR_API_KEY";
$params = http_build_query(["domain" => "acme-corp.com"]);

$ch = curl_init("https://api.veille.io/v1/domain?{$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{"domain": {"acme-corp.com"}}
    req, _ := http.NewRequest("GET", "https://api.veille.io/v1/domain?"+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.http.*;

var client  = HttpClient.newHttpClient();
var request = HttpRequest.newBuilder()
    .uri(URI.create("https://api.veille.io/v1/domain?domain=acme-corp.com"))
    .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 body = await client.GetStringAsync(
    "https://api.veille.io/v1/domain?domain=acme-corp.com");
Console.WriteLine(body);

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

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

Ergebnis interpretieren

Schlüsselfelder: is_registered, is_active, risk_score, creation_date, expiration_date, registrar.

print(f"Registriert  : {result['is_registered']}")
print(f"Aktiv        : {result['is_active']}")
print(f"Risiko-Score : {result['risk_score']}/100")
print(f"Erstellt     : {result.get('creation_date', 'N/A')}")
print(f"Läuft ab     : {result.get('expiration_date', 'N/A')}")
print(f"Registrar    : {result.get('registrar', 'N/A')}")

console.log(`Registriert  : ${result.is_registered}`);
console.log(`Aktiv        : ${result.is_active}`);
console.log(`Risiko-Score : ${result.risk_score}/100`);
console.log(`Erstellt     : ${result.creation_date ?? "N/A"}`);
console.log(`Läuft ab     : ${result.expiration_date ?? "N/A"}`);
console.log(`Registrar    : ${result.registrar ?? "N/A"}`);

echo "Registriert  : " . ($result["is_registered"] ? "true" : "false") . "\n";
echo "Aktiv        : " . ($result["is_active"]      ? "true" : "false") . "\n";
echo "Risiko-Score : {$result['risk_score']}/100\n";
echo "Erstellt     : " . ($result["creation_date"] ?? "N/A")   . "\n";
echo "Läuft ab     : " . ($result["expiration_date"] ?? "N/A") . "\n";
echo "Registrar    : " . ($result["registrar"] ?? "N/A")       . "\n";

fmt.Printf("Registriert  : %v\nAktiv        : %v\nRisiko-Score : %v/100\nErstellt     : %v\nLäuft ab     : %v\n",
    result["is_registered"], result["is_active"], result["risk_score"],
    result["creation_date"], result["expiration_date"])

import org.json.*;

var r = new JSONObject(response.body());
System.out.printf("Registriert  : %b%nAktiv        : %b%nRisiko-Score : %d/100%nErstellt     : %s%nLäuft ab     : %s%n",
    r.getBoolean("is_registered"), r.getBoolean("is_active"),
    r.getInt("risk_score"), r.optString("creation_date","N/A"), r.optString("expiration_date","N/A"));

using System.Text.Json;

var r = JsonDocument.Parse(body).RootElement;
Console.WriteLine($"Registriert  : {r.GetProperty("is_registered").GetBoolean()}");
Console.WriteLine($"Aktiv        : {r.GetProperty("is_active").GetBoolean()}");
Console.WriteLine($"Risiko-Score : {r.GetProperty("risk_score").GetInt32()}/100");
Console.WriteLine($"Erstellt     : {(r.TryGetProperty("creation_date", out var cd) ? cd.GetString() : "N/A")}");
Console.WriteLine($"Läuft ab     : {(r.TryGetProperty("expiration_date", out var ed) ? ed.GetString() : "N/A")}");

println!("Registriert  : {}", result["is_registered"]);
println!("Aktiv        : {}", result["is_active"]);
println!("Risiko-Score : {}/100", result["risk_score"]);
println!("Erstellt     : {}", result["creation_date"].as_str().unwrap_or("N/A"));
println!("Läuft ab     : {}", result["expiration_date"].as_str().unwrap_or("N/A"));

Domain-Validierung in Onboarding einbetten

Validieren Sie die Domain des Unternehmens während des Anmeldevorgangs und blockieren Sie verdächtige Domains.

import requests

API_KEY = "YOUR_API_KEY"

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

def onboard_company(company_name: str, domain: str) -> dict:
    v = validate_domain(domain)

    if not v.get("is_registered"):
        return {"ok": False, "error": f"Die Domain {domain} ist nicht registriert."}

    if not v.get("is_active"):
        return {"ok": False, "error": f"Die Domain {domain} scheint inaktiv zu sein."}

    if v.get("risk_score", 0) >= 70:
        return {"ok": False, "error": f"Die Domain {domain} hat einen hohen Risiko-Score ({v['risk_score']}/100)."}

    return {"ok": True, "message": f"{company_name} ({domain}) erfolgreich onboardet!"}

tests = [
    ("Acme Corp",  "acme-corp.com"),
    ("Bad Actor",  "totally-fake-domain-12345.xyz"),
    ("Big Co",     "stripe.com"),
]
for name, domain in tests:
    print(f"{name}: {onboard_company(name, domain)}")

const API_KEY = "YOUR_API_KEY";

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

async function onboardCompany(companyName: string, domain: string) {
  const v = await validateDomain(domain);
  if (!v.is_registered) return { ok: false, error: `Domain ${domain} ist nicht registriert.` };
  if (!v.is_active)     return { ok: false, error: `Domain ${domain} scheint inaktiv.` };
  if (v.risk_score >= 70) return { ok: false, error: `Domain ${domain} hat einen hohen Risiko-Score (${v.risk_score}/100).` };
  return { ok: true, message: `${companyName} (${domain}) erfolgreich onboardet!` };
}

for (const [name, domain] of [["Acme Corp", "acme-corp.com"], ["Bad Actor", "fake-domain.xyz"]]) {
  console.log(name, await onboardCompany(name, domain));
}

<?php
function validateDomain(string $apiKey, string $domain): array {
    $params = http_build_query(["domain" => $domain]);
    $ch     = curl_init("https://api.veille.io/v1/domain?{$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 onboardCompany(string $apiKey, string $name, string $domain): array {
    $v = validateDomain($apiKey, $domain);
    if (!($v["is_registered"] ?? false)) return ["ok" => false, "error" => "Domain nicht registriert."];
    if (!($v["is_active"]     ?? false)) return ["ok" => false, "error" => "Domain inaktiv."];
    if (($v["risk_score"]     ?? 0) >= 70) return ["ok" => false, "error" => "Hoher Risiko-Score: {$v['risk_score']}/100."];
    return ["ok" => true, "message" => "{$name} ({$domain}) erfolgreich onboardet!"];
}

foreach ([["Acme Corp", "acme-corp.com"], ["Bad Actor", "fake-domain-xyz.xyz"]] as [$name, $domain]) {
    print_r(onboardCompany("YOUR_API_KEY", $name, $domain));
}

package main

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

const APIKey = "YOUR_API_KEY"

func validateDomain(domain string) map[string]any {
    params := url.Values{"domain": {domain}}
    req, _ := http.NewRequest("GET", "https://api.veille.io/v1/domain?"+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 onboard(name, domain string) string {
    v := validateDomain(domain)
    if !(v["is_registered"].(bool)) { return "❌ Domain nicht registriert." }
    if !(v["is_active"].(bool))     { return "❌ Domain inaktiv." }
    if v["risk_score"].(float64) >= 70 { return fmt.Sprintf("❌ Hoher Risiko-Score: %.0f/100.", v["risk_score"]) }
    return fmt.Sprintf("✅ %s (%s) erfolgreich onboardet!", name, domain)
}

func main() {
    pairs := [][2]string{{"Acme Corp", "acme-corp.com"}, {"Bad Actor", "fake-domain.xyz"}, {"Stripe", "stripe.com"}}
    for _, p := range pairs {
        fmt.Printf("%s: %s\n", p[0], onboard(p[0], p[1]))
    }
}

import java.net.URI;
import java.net.http.*;
import org.json.*;

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

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

    static String onboard(String name, String domain) throws Exception {
        var v = validate(domain);
        if (!v.getBoolean("is_registered")) return "❌ Domain nicht registriert.";
        if (!v.getBoolean("is_active"))     return "❌ Domain inaktiv.";
        if (v.getInt("risk_score") >= 70)   return "❌ Hoher Risiko-Score: " + v.getInt("risk_score") + "/100.";
        return "✅ " + name + " (" + domain + ") erfolgreich onboardet!";
    }

    public static void main(String[] args) throws Exception {
        for (var pair : new String[][]{{"Acme Corp","acme-corp.com"},{"Bad Actor","fake.xyz"},{"Stripe","stripe.com"}})
            System.out.println(pair[0] + ": " + onboard(pair[0], pair[1]));
    }
}

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> ValidateDomain(string domain)
{
    var body = await client.GetStringAsync($"https://api.veille.io/v1/domain?domain={domain}");
    return JsonDocument.Parse(body).RootElement;
}

async Task<string> Onboard(string name, string domain)
{
    var v = await ValidateDomain(domain);
    if (!v.GetProperty("is_registered").GetBoolean())   return $"❌ Domain {domain} nicht registriert.";
    if (!v.GetProperty("is_active").GetBoolean())       return $"❌ Domain {domain} inaktiv.";
    if (v.GetProperty("risk_score").GetInt32() >= 70)   return $"❌ Hoher Risiko-Score: {v.GetProperty("risk_score").GetInt32()}/100.";
    return $"✅ {name} ({domain}) erfolgreich onboardet!";
}

foreach (var (name, domain) in new[] { ("Acme Corp", "acme-corp.com"), ("Bad Actor", "fake.xyz"), ("Stripe", "stripe.com") })
    Console.WriteLine($"{name}: {await Onboard(name, domain)}");

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

const API_KEY: &str = "YOUR_API_KEY";

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

async fn onboard(client: &Client, name: &str, domain: &str) -> String {
    let v = validate_domain(client, domain).await;
    if !v["is_registered"].as_bool().unwrap_or(false) { return format!("❌ Domain {} nicht registriert.", domain); }
    if !v["is_active"].as_bool().unwrap_or(false)     { return format!("❌ Domain {} inaktiv.", domain); }
    if v["risk_score"].as_i64().unwrap_or(0) >= 70    { return format!("❌ Hoher Risiko-Score: {}/100.", v["risk_score"]); }
    format!("✅ {} ({}) erfolgreich onboardet!", name, domain)
}

#[tokio::main]
async fn main() -> Result<(), reqwest::Error> {
    let client = Client::new();
    let pairs  = [("Acme Corp", "acme-corp.com"), ("Bad Actor", "fake.xyz"), ("Stripe", "stripe.com")];
    for (name, domain) in pairs {
        println!("{}: {}", name, onboard(&client, name, domain).await);
    }
    Ok(())
}

Sehr junge Domains (wenige Tage alt) sind ein starkes Betrugs-Signal. Ergänzen Sie risk_score um eine Prüfung des Domänenalters mit creation_date, um Wegwerf-Unternehmensdomänen zu erkennen.