Hitta företags webbplatser med Python och API

För att hitta ett företags webbplats utifrån företagsnamnet i Python skickar du namnet och eventuell tillgänglig landsinformation till Datablists Company Name to Domain API. API:et bearbetar sökningen i bakgrunden och returnerar sedan domänen och den fullständiga webbadressen.

Först visar jag en enkel API-request i Python. Därefter återanvänder jag samma funktion för att endast fylla i webbplatser som saknas i en lista med företagsposter, utan att ändra de URL:er som redan finns.

Om du föredrar ett kalkylbladsliknande gränssnitt kan du följa vår guide för att hitta webbplatser från företagsnamn i bulk.

💡 Snabb sammanfattning

Skapa en Python-funktion som hittar webbplatser från företagsnamn och använd den sedan för att komplettera poster där webbplatsen saknas, utan att ersätta kända URL:er.

• Input: företagsnamn med valfri landsinformation.
• Output: domän, fullständig webbplats-URL, konfidensnivå, resultatstatus och förbrukade credits.

Konfigurera Python och din Datablist API-nyckel

I det här exemplet använder jag paketet Requests för synkrona HTTP-anrop. Installera det i en virtuell miljö:

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

Du behöver också Datablist Growth eftersom åtkomst till REST API är en Growth-funktion. Skapa en Personal API Key på din API-kontosida i Datablist och lägg sedan nyckeln i en miljövariabel:

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

🔑 Har du redan en API-nyckel? Äldre nycklar använder formatet auth0|<userId>:<accountId>:<secret>:1. De stöds fortfarande. Fortsätt använda din befintliga nyckel exakt som den genererades – du behöver varken byta ut eller formatera om den.

Ersätt exempelvärdet ovan med nyckeln som genererades på din kontosida. Sökningar efter företagswebbplatser förbrukar credits. Innan vi skalar upp scriptet förklarar jag alternativen som kostar 1 respektive 2,5 credits. Aktuella priser hittar du på Datablists prissida.

Sök efter en företagswebbplats med Python

Skapa en fil med namnet find_company_websites.py. Scriptet skickar in namnen, väntar på att jobbet ska bli klart och hämtar resultaten i en och samma funktion. Varje input använder postens stabila ID som inputId, så att du kan koppla varje resultat till rätt post även om ordningen i svaret ändras.

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))

Kör scriptet i terminalen där du exporterade nyckeln:

1python find_company_websites.py

Så här ser resultatet för Microsoft ut:

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

Använd inputId för att koppla resultatet till den ursprungliga posten. status kan vara success, no_result, error eller skipped. Ett lyckat resultat kan innehålla companyDomain, hela companyUrl och domainConfidence. creditsUsed visar kostnaden för denna input, medan error förklarar eventuella fel på postnivå.

Funktionen gör tre typer av API-anrop i tur och ordning.

Först skickar den in sökningen. Payloaden innehåller inställningarna och företagsposterna. POST-anropet returnerar 202 Accepted, och @id är det task-ID som behövs i nästa anrop:

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"]

Om DATABLIST_API_KEY inte är definierad utlöser Python ett KeyError när miljövariabeln läses, innan någon HTTP-request görs. Exportera variabeln och kör sedan scriptet igen. Om variabeln innehåller en ogiltig nyckel når POST-anropet API:et och returnerar HTTP 401. Kopiera en aktuell Personal API Key från din kontosida och ersätt det ogiltiga värdet.

Därefter pollar den jobbet. POST-anropet startar ett bakgrundsjobb, så scriptet hämtar dess status var tredje sekund tills den blir completed, failed eller stopped:

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)

Om jobbet misslyckas på grund av att det saknas credits anges orsaken credits_error i felmeddelandet. Lägg till credits eller vänta tills dina månadscredits förnyas, granska eventuella resultat som redan har returnerats och skicka sedan endast de ofärdiga posterna i ett nytt jobb.

Till sist hämtar den alla resultatsidor. Varje svar lägger till resultat i listan och innehåller den cursor som behövs för nästa request:

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

Scriptet fortsätter att hämta nästa sida tills nextCursor är null.

Scriptet skriver ut det genererade uniqueId före POST-anropet. Om anslutningen bryts innan du får svaret som bekräftar att jobbet skapats bör du först lista dina jobb och kontrollera deras status innan du skapar ett nytt:

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"

Leta upp jobbet vars uniqueId matchar värdet som scriptet genererade och kopiera dess @id. List-endpointen kan filtrera efter enrichmentId, men inte efter uniqueId. Använd detta @id med samma URL:er för status och resultat som scriptet använder. Fortsätt polla jobbet om det fortfarande är aktivt. Om det har stoppats eller misslyckats bör du kontrollera om det finns delresultat innan du skickar in posterna igen.

Så fungerar datasetmatchning och landbaserad fallback

Scriptet använder dataset_google, vilket är den rekommenderade standardinställningen. Datablist söker först i sina företagsdataset. Om en matchning saknas eller om uppgifterna inte stämmer överens kan Google användas som fallback. Möjliga träffar kontrolleras innan en konfidensnivå returneras.

Landsinformation hjälper när företagsnamn är tvetydiga. I det här exemplet gav samma företagsnamn olika resultat:

• Mercury med US returnerade shipmercury.com och https://www.shipmercury.com/.
• Mercury med IE returnerade mercuryeng.com och http://www.mercuryeng.com.

Båda hade konfidensnivån High. Landsinformationen hjälper sökningen att välja mellan företag med samma namn, medan konfidensnivån visar vilka resultat som behöver granskas.

När matchningen även beror på bransch, företagsstorlek eller annan affärskontext kan du använda research-flödet med AI Agent. Lägg till dessa uppgifter i din AI Agent-prompt, så att agenten kan hitta rätt företag med hjälp av mer detaljerad affärskontext.

Fyll endast i webbplatser som saknas

Nu när find_domains() kan hitta en webbplats från ett företagsnamn kan du återanvända funktionen för att endast fylla i saknade webbplatser i dina företagsposter. Poster som redan har en webbplats skickas inte till API:et. Deras värden förblir därför oförändrade och inga credits förbrukas för dem.

I find_company_websites.py ersätter du allt från companies = [ till och med den sista utskriftsloopen med kodblocket nedan. Behåll tilldelningen av api_key ovanför blocket. Kontrollen av tomma värden hanterar None, en tom sträng och blanksteg. Inget API-anrop görs om alla poster redan har en webbplats.

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))

Koden indexerar resultaten efter inputId och går sedan igenom originalposterna i ordning. Objektet website_lookup sparar utfallet och granskningsinformationen bredvid varje post som behandlats, inklusive misslyckade resultat och resultat som saknas.

För crm-001 returnerar website_is_missing() värdet False, eftersom Microsofts URL redan finns. Posten läggs inte till i records_to_lookup, så API:et tar aldrig emot den. Vid sammanslagningen behålls webbplatsen och statusen anges som not_requested.

För crm-002 är webbplatsfältet tomt, så bageriet skickas i requesten med inputId: crm-002. API:et returnerar samma inputId. results_by_id använder detta ID för att hitta rätt resultat, och vid sammanslagningen skrivs https://boulangerie-du-palais-lyon.eatbu.com till rätt post utan att koden behöver förlita sig på resultatens ordning.

Bageriet använder en företagsspecifik subdomän, boulangerie-du-palais-lyon.eatbu.com. Behåll det värdet i stället för att korta ned det till eatbu.com, och spara den exakta adressen från companyUrl. Inställningen acceptNonRoot: true tillåter även en hostad företagssida vars adress innehåller en sökväg efter värdnamnet. Därför är hela URL:en viktig i båda fallen.

Ett slutfört jobb kan fortfarande innehålla poster med no_result, error eller skipped. Exemplet ändrar endast website när statusen är success och companyUrl finns. Vid no_result lämnas webbplatsfältet tomt och statusen syns fortfarande i website_lookup. Kontrollera först företagsnamnet och landet. Om någon av uppgifterna är fel rättar du den och skickar posten i ett nytt jobb. Annars låter du webbplatsfältet förbli tomt för manuell granskning.

Beräkna credits innan du skalar upp scriptet

Alla fem exempelsökningar returnerade success med konfidensnivån High och använde sammanlagt 5 credits.

En sökning som löses via datasetet kostar 1 credit. En sökning som bearbetas med Google kostar 2,5 credits. Du betalar för den väg som används, inte för båda. För 1 000 inputs innebär det 1 000 credits om alla löses via datasetet eller 2 500 credits om alla använder Google. Det här är beräkningsscenarier, inte ett löfte om att varje sökning ger ett resultat.

Flytta reglaget för att jämföra förbrukningen av credits för din lista.

Med ett pris på 20 USD för 20 000 credits kostar dessa scenarier 1 USD respektive 2,50 USD. Growth-prenumerationen är separat och innehåller för närvarande 20 000 credits per månad, vilka används före eventuella tilläggsköp. Se aktuella priser, eftersom priser och paket kan ändras.

Ett jobb kan ta emot upp till 10 000 inputs, med en gräns på 16 KiB per input och 10 MiB per request. Det här exemplet använder blockerande Requests-anrop för att skicka, polla och hämta resultat från ett litet asynkront Datablist-jobb. Det underhållna kodbiblioteket innehåller även exempel på CSV-batchning och icke-blockerande klienter.

Nästa steg

När du har verifierat att en returnerad webbplats tillhör rätt företag kan du scrapa dess Impressum med Python för att lägga till juridiska företagsuppgifter och URL:en till den juridiska källsidan i samma leverantörspost. Håll granskningen av webbplatsmatchningen åtskild från den efterföljande dataextraktionen.

Ersätt exempelposterna med ett litet urval av dina egna data. Kör sedan scriptet och granska de sammanslagna posterna. Behåll stabila ID:n och landsinformation, och skala inte upp förrän du har bekräftat att scriptet bevarar befintliga webbplatser och fyller i rätt tomma fält. Du kan utgå från de underhållna exemplen för Company Name to Domain API på GitHub om du vill ha ett nedladdningsbart script, CSV-batchning eller en asynkron version.