Unternehmenswebsites mit Python und API finden

Um die Website eines Unternehmens anhand seines Namens mit Python zu finden, sendest Du den Namen und – sofern vorhanden – das Land an die Company Name to Domain API von Datablist. Die API verarbeitet die Suche im Hintergrund und gibt anschließend die Domain sowie die vollständige Website-URL zurück.

Zuerst zeige ich Dir einen einfachen Python-API-Request. Danach verwenden wir dieselbe Funktion, um in einer Liste von Unternehmensdatensätzen nur die fehlenden Websites zu ergänzen. Bereits vorhandene URLs bleiben dabei erhalten.

Wenn Du lieber mit einer Oberfläche wie in einer Tabellenkalkulation arbeitest, hilft Dir unser Guide zur Bulk-Suche von Unternehmenswebsites weiter.

💡 Kurzfassung für Eilige

Erstelle eine Python-Funktion, die anhand von Unternehmensnamen die passenden Websites findet. Nutze sie anschließend, um Datensätze mit leeren Website-Feldern zu vervollständigen, ohne bekannte URLs zu überschreiben.

• Input: Unternehmensnamen, optional mit Land.
• Output: Domain, vollständige Website-URL, Konfidenz, Ergebnisstatus und verbrauchte Credits.

Python und Deinen Datablist API Key einrichten

Für dieses Beispiel verwende ich das Requests-Paket, um synchrone HTTP-Requests zu senden. Installiere es in einer virtuellen Umgebung:

1python3 -m venv .venv
2source .venv/bin/activate
3python -m pip install requests

Du benötigst außerdem einen Datablist Growth-Tarif, da der Zugriff auf die REST API eine Growth-Funktion ist. Erstelle auf Deiner Datablist API-Kontoseite einen Personal API Key und speichere ihn anschließend in einer Umgebungsvariable:

1export DATABLIST_API_KEY="exampleuser-exampleaccount-EXAMPLE_TOKEN_NOT_VALID-2"

🔑 Du hast bereits einen API Key? Ältere Keys verwenden das Format auth0|<userId>:<accountId>:<secret>:1. Sie werden weiterhin unterstützt. Nutze Deinen vorhandenen Key genau so, wie er erstellt wurde – Du musst ihn weder ersetzen noch neu formatieren.

Ersetze den Beispielwert durch den Key aus Deiner Kontoseite. Die Suche nach Unternehmenswebsites verbraucht Credits. Bevor wir das Script skalieren, erkläre ich Dir die Varianten mit 1 beziehungsweise 2,5 Credits. Die aktuellen Tarifwerte findest Du auf der Datablist-Preisseite.

Eine Unternehmenswebsite mit Python finden

Erstelle eine Datei namens find_company_websites.py. Das Script übermittelt die Namen, wartet auf die Verarbeitung des Tasks und ruft die Ergebnisse ab – alles innerhalb einer einzigen Funktion. Jeder Input verwendet Deine dauerhafte Datensatz-ID als inputId. So kannst Du jedes Ergebnis dem richtigen Datensatz zuordnen, selbst wenn sich die Reihenfolge der Response ändert.

1import json
2import os
3import time
4import uuid
5
6import requests
7
8
9API_BASE_URL = "https://api.datablist.com/v1"
10
11
12def find_domains(companies, api_key):
13    headers = {
14        "Accept": "application/json",
15        "Content-Type": "application/json",
16        "X-API-Key": api_key,
17    }
18    inputs = [
19        {
20            "inputId": company["id"],
21            "data": {
22                "companyName": company["company_name"],
23                "targetCountry": company.get("country", ""),
24            },
25        }
26        for company in companies
27    ]
28    unique_id = f"python-domain-lookup-{uuid.uuid4().hex}"
29    payload = {
30        "enrichmentId": "company-name-to-domain",
31        "uniqueId": unique_id,
32        "settings": {
33            "workflow": "dataset_google",
34            "countryOverwrite": True,
35            "acceptNonRoot": True,
36        },
37        "inputs": inputs,
38    }
39
40    print(f"Task uniqueId: {unique_id}")
41    response = requests.post(
42        f"{API_BASE_URL}/enrichments/tasks",
43        headers=headers,
44        json=payload,
45    )
46    response.raise_for_status()
47    task_id = response.json()["@id"]
48
49    while True:
50        response = requests.get(
51            f"{API_BASE_URL}/enrichments/tasks/{task_id}",
52            headers=headers,
53        )
54        response.raise_for_status()
55        task = response.json()
56        if task["status"] in {"completed", "failed", "stopped"}:
57            break
58        time.sleep(3)
59
60    if task["status"] != "completed":
61        raise RuntimeError(
62            f"Task {task_id} ended with status {task['status']}: {task.get('error')}"
63        )
64
65    results = []
66    cursor = None
67    while True:
68        params = {"limit": 100}
69        if cursor is not None:
70            params["cursor"] = cursor
71
72        response = requests.get(
73            f"{API_BASE_URL}/enrichments/tasks/{task_id}/results",
74            headers=headers,
75            params=params,
76        )
77        response.raise_for_status()
78        page = response.json()
79        results.extend(page["results"])
80        cursor = page.get("nextCursor")
81        if cursor is None:
82            break
83
84    return results
85
86
87api_key = os.environ["DATABLIST_API_KEY"]
88companies = [
89    {
90        "id": "direct-microsoft-us",
91        "company_name": "Microsoft",
92        "country": "US",
93    }
94]
95
96lookup_results = find_domains(companies, api_key)
97for result in lookup_results:
98    print(json.dumps(result, indent=2))

Führe das Script in dem Terminal aus, in dem Du den Key exportiert hast:

1python find_company_websites.py

So sieht das Ergebnis für Microsoft aus:

{
  "inputId": "direct-microsoft-us",
  "status": "success",
  "outputs": {
    "companyUrl": "https://microsoft.com",
    "companyDomain": "microsoft.com",
    "domainConfidence": "High"
  },
  "creditsUsed": "1",
  "error": null
}

Mit inputId ordnest Du das Ergebnis dem ursprünglichen Datensatz zu. status kann success, no_result, error oder skipped sein. Ein erfolgreiches Ergebnis kann companyDomain, die vollständige companyUrl und domainConfidence enthalten. creditsUsed zeigt die Kosten für diesen Input, während error einen Fehler auf Datensatzebene erläutert.

Die Funktion führt nacheinander drei Arten von API-Calls aus.

Zuerst übermittelt sie die Suchanfrage. Der Payload enthält die Einstellungen und Unternehmensdatensätze. Der POST-Request gibt 202 Accepted zurück. @id ist die Task-ID, die für die folgenden Requests benötigt wird:

1response = requests.post(
2    f"{API_BASE_URL}/enrichments/tasks",
3    headers=headers,
4    json=payload,
5)
6response.raise_for_status()
7task_id = response.json()["@id"]

Wenn DATABLIST_API_KEY nicht gesetzt ist, löst Python beim Auslesen der Umgebungsvariable einen KeyError aus, noch bevor ein HTTP-Request gesendet wird. Exportiere die Variable und starte das Script erneut. Enthält sie einen ungültigen Key, erreicht der POST-Request die API und gibt HTTP 401 zurück. Kopiere einen aktuellen Personal API Key von Deiner Kontoseite und ersetze damit den ungültigen Wert.

Danach fragt sie den Task-Status ab. Da der POST-Request die Verarbeitung im Hintergrund startet, ruft das Script den Task alle drei Sekunden ab, bis er den Status completed, failed oder stopped erreicht:

1while True:
2    response = requests.get(
3        f"{API_BASE_URL}/enrichments/tasks/{task_id}",
4        headers=headers,
5    )
6    response.raise_for_status()
7    task = response.json()
8    if task["status"] in {"completed", "failed", "stopped"}:
9        break
10    time.sleep(3)

Schlägt der Task wegen fehlender Credits fehl, enthält der Fehler den Grund credits_error. Füge Credits hinzu oder warte, bis Deine monatlichen Credits erneuert werden. Prüfe bereits zurückgegebene Ergebnisse und übermittle anschließend nur die noch nicht verarbeiteten Inputs in einem neuen Task.

Zum Schluss ruft sie alle Ergebnisseiten ab. Jede Response ergänzt die Ergebnisliste und liefert den Cursor für den nächsten Request:

1results.extend(page["results"])
2cursor = page.get("nextCursor")
3if cursor is None:
4    break

Die Funktion ruft so lange weitere Seiten ab, bis nextCursor den Wert null hat.

Vor dem POST-Request gibt das Script die generierte uniqueId aus. Falls die Verbindung abbricht, bevor Du die Response zur Task-Erstellung erhältst, solltest Du zunächst Deine Tasks auflisten und ihren Status prüfen, bevor Du einen weiteren Task erstellst:

1curl --get "https://api.datablist.com/v1/enrichments/tasks" \
2  --header "X-API-Key: $DATABLIST_API_KEY" \
3  --data-urlencode "enrichmentId=company-name-to-domain"

Suche nach dem Task, dessen uniqueId mit dem vom Script generierten Wert übereinstimmt, und kopiere seine @id. Der Listen-Endpunkt kann nach enrichmentId, aber nicht nach uniqueId filtern. Verwende die @id mit denselben Status- und Ergebnis-URLs wie im Script. Ist der Task noch aktiv, frage seinen Status weiter ab. Wurde er gestoppt oder ist er fehlgeschlagen, prüfe zunächst, ob Teilergebnisse vorliegen, bevor Du die Inputs erneut übermittelst.

Dataset-Matching und länderspezifischen Fallback verstehen

Das Script verwendet dataset_google, die empfohlene Standardeinstellung. Datablist durchsucht zuerst seine Unternehmensdatensätze. Fehlt ein Match oder sind die Ergebnisse widersprüchlich, kann Google als Fallback verwendet werden. Mögliche Treffer werden geprüft, bevor die API einen Konfidenzwert zurückgibt.

Das Land hilft bei mehrdeutigen Namen. In diesem Beispiel führte derselbe Unternehmensname zu unterschiedlichen Ergebnissen:

• Mercury mit US ergab shipmercury.com und https://www.shipmercury.com/.
• Mercury mit IE ergab mercuryeng.com und http://www.mercuryeng.com.

Beide Treffer hatten die Konfidenz High. Das Land hilft der Suche, zwischen Unternehmen mit demselben Namen zu unterscheiden. Anhand der Konfidenz kannst Du anschließend entscheiden, welche Ergebnisse geprüft werden sollten.

Hängt das Match zusätzlich von Branche, Unternehmensgröße oder anderem geschäftlichen Kontext ab, nutze den AI Agent Research Workflow. Ergänze diese Angaben im Prompt des AI Agent, damit er mit einem umfassenderen Geschäftskontext nach dem richtigen Unternehmen suchen kann.

Nur fehlende Websites in Datensätzen ergänzen

Da find_domains() jetzt anhand eines Unternehmensnamens eine Website findet, kannst Du die Funktion nutzen, um ausschließlich fehlende Websites in Deinen Unternehmensdatensätzen zu ergänzen. Datensätze, die bereits eine Website enthalten, umgehen die API. Ihre Werte bleiben dadurch unverändert und verbrauchen keine Lookup-Credits.

Ersetze in find_company_websites.py alles ab companies = [ bis einschließlich der letzten Print-Schleife durch den folgenden Block. Behalte die darüberstehende Zuweisung von api_key bei. Die Prüfung auf leere Werte berücksichtigt None, einen leeren String und reine Leerzeichen. Sind alle Websites vorhanden, erfolgt kein API-Call.

1records = [
2    {
3        "id": "crm-001",
4        "company_name": "Microsoft",
5        "country": "US",
6        "website": "https://www.microsoft.com",
7    },
8    {
9        "id": "crm-002",
10        "company_name": "boulangerie du palais lyon",
11        "country": "FR",
12        "website": "",
13    },
14    {
15        "id": "crm-003",
16        "company_name": "Mercury Engineering",
17        "country": "IE",
18        "website": None,
19    },
20    {
21        "id": "crm-004",
22        "company_name": "Mercury",
23        "country": "US",
24        "website": "   ",
25    },
26    {
27        "id": "crm-005",
28        "company_name": "Datablist",
29        "country": "FR",
30        "website": "https://www.datablist.com",
31    },
32    {
33        "id": "crm-006",
34        "company_name": "Mercury",
35        "country": "IE",
36        "website": None,
37    },
38]
39
40
41def website_is_missing(value):
42    return not isinstance(value, str) or not value.strip()
43
44
45records_to_lookup = [
46    record for record in records if website_is_missing(record.get("website"))
47]
48lookup_results = (
49    find_domains(records_to_lookup, api_key) if records_to_lookup else []
50)
51results_by_id = {result["inputId"]: result for result in lookup_results}
52
53for record in records:
54    if not website_is_missing(record.get("website")):
55        record["website_lookup"] = {"status": "not_requested"}
56        continue
57
58    result = results_by_id.get(record["id"])
59    if result is None:
60        record["website_lookup"] = {
61            "status": "missing_result",
62            "domain": None,
63            "confidence": None,
64            "credits": None,
65            "error": {
66                "code": "missing_result",
67                "message": "No result was returned for this inputId.",
68            },
69        }
70        continue
71
72    outputs = result.get("outputs") or {}
73    if result["status"] == "success" and outputs.get("companyUrl"):
74        record["website"] = outputs["companyUrl"]
75
76    record["website_lookup"] = {
77        "status": result["status"],
78        "domain": outputs.get("companyDomain"),
79        "confidence": outputs.get("domainConfidence"),
80        "credits": result.get("creditsUsed"),
81        "error": result.get("error"),
82    }
83
84print(json.dumps(records, indent=2))

Der Code indexiert die Ergebnisse anhand der inputId und durchläuft danach die ursprünglichen Datensätze in ihrer bestehenden Reihenfolge. Das Objekt website_lookup speichert das Ergebnis und die Angaben für die spätere Prüfung direkt beim jeweiligen Datensatz – auch bei erfolglosen oder fehlenden Ergebnissen.

Für crm-001 gibt website_is_missing() den Wert False zurück, da die Microsoft-URL bereits vorhanden ist. Der Datensatz wird nicht zu records_to_lookup hinzugefügt und daher nie an die API gesendet. Beim Zusammenführen bleibt die Website erhalten; als Status wird not_requested gespeichert.

Bei crm-002 ist das Website-Feld leer. Deshalb wird die Bäckerei mit inputId: crm-002 übermittelt. Die API gibt dieselbe inputId zurück. results_by_id findet damit das richtige Ergebnis, und beim Zusammenführen wird https://boulangerie-du-palais-lyon.eatbu.com in den Datensatz geschrieben – unabhängig von der Reihenfolge der Ergebnisse.

Die Bäckerei verwendet die geschäftsspezifische Subdomain boulangerie-du-palais-lyon.eatbu.com. Behalte diesen Wert bei, statt ihn auf eatbu.com zu kürzen, und speichere die exakte Adresse aus companyUrl. Mit der Einstellung acceptNonRoot: true sind außerdem gehostete Unternehmensseiten erlaubt, deren Adresse nach dem Hostnamen einen Pfad enthält. Deshalb ist in beiden Fällen die vollständige URL wichtig.

Auch ein abgeschlossener Task kann Einträge mit no_result, error oder skipped enthalten. Das Beispiel ändert website nur, wenn der Status success lautet und companyUrl vorhanden ist. Bei no_result bleibt die Website leer und der Status ist weiterhin in website_lookup sichtbar. Prüfe zuerst den Unternehmensnamen und das Land. Ist einer der Inputs falsch, korrigiere ihn und übermittle den Datensatz in einem neuen Task. Andernfalls lässt Du das Website-Feld für eine manuelle Prüfung sichtbar leer.

Lookup-Credits vor dem Skalieren kalkulieren

Alle fünf Beispielabfragen waren mit der Konfidenz High erfolgreich und haben insgesamt 5 Credits verbraucht.

Ein über das Dataset aufgelöster Lookup kostet 1 Credit. Ein mit Google verarbeiteter Lookup kostet 2,5 Credits. Du bezahlst nur für den tatsächlich genutzten Weg, nicht für beide. Bei 1.000 Inputs sind das 1.000 Credits, wenn alle über das Dataset aufgelöst werden, oder 2.500 Credits, wenn für alle Google verwendet wird. Diese Zahlen dienen der Planung und sind keine Garantie dafür, dass jeder Lookup erfolgreich ist.

Bewege den Regler, um den Credit-Verbrauch für Deine Liste zu vergleichen.

Bei 20 US-Dollar für 20.000 Credits kosten diese Szenarien 1 beziehungsweise 2,50 US-Dollar. Das Growth-Abonnement wird separat abgerechnet und umfasst derzeit 20.000 monatliche Credits, die vor zusätzlich gekauften Credits verbraucht werden. Prüfe die aktuellen Preise, da sich Tarif- und Paketwerte ändern können.

Ein Task akzeptiert bis zu 10.000 Inputs, wobei pro Input ein Limit von 16 KiB und pro Request ein Limit von 10 MiB gilt. Dieses Beispiel verwendet blockierende Requests-Aufrufe, um einen kleinen asynchronen Datablist-Task zu übermitteln, seinen Status abzufragen und die Ergebnisse abzurufen. Das gepflegte Repository enthält außerdem Beispiele für CSV-Batching und nicht blockierende Clients.

Nächste Schritte

Sobald Du geprüft hast, dass eine gefundene Website zum gewünschten Unternehmen gehört, kannst Du das Impressum mit Python auslesen. So ergänzt Du denselben Lieferantendatensatz um rechtliche Unternehmensangaben und die URL der als Quelle verwendeten Impressumsseite. Prüfe den Website-Match unabhängig von der späteren Datenextraktion.

Ersetze die Beispieldatensätze durch einen kleinen Ausschnitt Deiner eigenen Daten. Führe anschließend das Script aus und prüfe die zusammengeführten Datensätze. Verwende dauerhafte IDs und das jeweilige Land. Skaliere erst, wenn das Script bekannte Websites zuverlässig beibehält und die erwarteten Lücken füllt. Wenn Du ein fertiges Script, CSV-Batching oder eine asynchrone Version suchst, kannst Du mit den gepflegten Company Name to Domain API-Beispielen auf GitHub starten.