Find LinkedIn-virksomhedssider fra websites med Python

Brug Datablists Company to LinkedIn API til at finde en virksomheds LinkedIn-side ud fra dens website med Python. Du kan sende et rent domæne eller en komplet website-URL, vente på matching-opgaven og få virksomhedens navn, website, LinkedIn-URL og et confidence-signal retur.

I denne guide bruger jeg Python og Requests-biblioteket til at matche fem virksomhedswebsites. Listen omfatter velkendte softwarevirksomheder samt VAUDE, der producerer outdoorudstyr, og Drooms, der tilbyder virtuelle datarum. Derefter opdeler jeg resultaterne i to lokale køer: matches, der er klar til virksomhedsresearch, og matches, der kræver manuel kontrol.

🔑 Kort fortalt til dig, der har travlt

Send websites fra din account-liste til Datablists Company to LinkedIn API. API'et returnerer URL'er til LinkedIn-virksomhedssider og confidence-signaler, så du kan afgøre, hvilke matches du kan bruge direkte, og hvilke du bør kontrollere.

• Input: rene domæner og komplette URL'er til virksomhedswebsites.
• Output: virksomhedsnavne, matchede websites, URL'er til LinkedIn-virksomhedssider samt high eller low confidence, opdelt i køerne Ready for research og Needs review.

💡 Foretrækker du en no-code-løsning? Brug Datablists LinkedIn Company Pages & Domain Lookup til at matche virksomhedswebsites og LinkedIn-sider uden at skrive kode.

Opsæt Python og din Datablist API key

I dette eksempel bruger jeg pakken requests. Selve API'et fungerer via HTTP, så du kan senere overføre den samme rækkefølge af requests til et andet programmeringssprog.

Du skal have en Datablist-konto med adgang til REST API, som er inkluderet i Growth-abonnementet. Vellykkede opslag bruger også enrichment credits. Den præcise beregning af credits gennemgår jeg senere i guiden.

Opret en arbejdsmappe og filen find_linkedin_company_pages.py. Opret derefter et virtuelt miljø, og installer Requests:

1mkdir company-linkedin-matcher
2cd company-linkedin-matcher
3python -m venv .venv
4source .venv/bin/activate
5python -m pip install requests
6touch find_linkedin_company_pages.py

Opret en Personal API Key på din Datablist-konto, og eksporter den som en miljøvariabel:

1export DATABLIST_API_KEY="your-api-key"

Scriptet læser denne værdi og sender den i headeren X-API-Key.

Find LinkedIn-virksomhedssider med én Python-funktion

Eksemplet bruger disse fem accounts som kildedata:

• account-datablist: datablist.com
• account-posthog: posthog.com
• account-n8n: https://n8n.io
• account-vaude: vaude.com
• account-drooms: https://www.drooms.com

Hvert account_id bliver til API-feltet inputId. Det er vigtigt, fordi resultaterne ikke nødvendigvis ankommer i samme rækkefølge som inputtene. Med et stabilt ID kan du koble hvert resultat til den korrekte account i kildedataene.

Indsæt hele dette script i find_linkedin_company_pages.py:

1import json
2import os
3import time
4import uuid
5
6import requests
7
8
9def match_companies(accounts, api_key, matching_direction):
10    """Submit one matching task, wait for it, and return every result."""
11    tasks_url = "https://api.datablist.com/v1/enrichments/tasks"
12    headers = {"X-API-Key": api_key}
13    inputs = [
14        {
15            "inputId": account["account_id"],
16            "data": {"sourceUrl": account["source_url"]},
17        }
18        for account in accounts
19    ]
20
21    unique_id = str(uuid.uuid4())
22    print(f"Task uniqueId: {unique_id}", flush=True)
23    payload = {
24        "enrichmentId": "company-to-linkedin",
25        "uniqueId": unique_id,
26        "settings": {"matchingDirection": matching_direction},
27        "inputs": inputs,
28    }
29    response = requests.post(tasks_url, headers=headers, json=payload)
30    response.raise_for_status()
31    task = response.json()
32    task_id = task["@id"]
33    task_url = f"{tasks_url}/{task_id}"
34
35    while task["status"] not in ("completed", "failed", "stopped"):
36        time.sleep(3)
37        response = requests.get(task_url, headers=headers)
38        response.raise_for_status()
39        task = response.json()
40
41    if task["status"] != "completed":
42        raise RuntimeError(
43            f"Task {task_id} {task['status']}: {task.get('error')}"
44        )
45
46    results = []
47    results_url = f"{task_url}/results"
48    params = {"limit": 100}
49    while True:
50        response = requests.get(results_url, headers=headers, params=params)
51        response.raise_for_status()
52        page = response.json()
53        results.extend(page["results"])
54        next_cursor = page["nextCursor"]
55        if next_cursor is None:
56            break
57        params["cursor"] = next_cursor
58
59    return results
60
61
62accounts = [
63    {
64        "account_id": "account-datablist",
65        "company_name": "Datablist",
66        "source_url": "datablist.com",
67    },
68    {
69        "account_id": "account-posthog",
70        "company_name": "PostHog",
71        "source_url": "posthog.com",
72    },
73    {
74        "account_id": "account-n8n",
75        "company_name": "n8n",
76        "source_url": "https://n8n.io",
77    },
78    {
79        "account_id": "account-vaude",
80        "company_name": "VAUDE",
81        "source_url": "vaude.com",
82    },
83    {
84        "account_id": "account-drooms",
85        "company_name": "Drooms",
86        "source_url": "https://www.drooms.com",
87    },
88]
89
90api_key = os.environ.get("DATABLIST_API_KEY")
91if not api_key:
92    raise RuntimeError("Set DATABLIST_API_KEY before running this script.")
93
94match_results = match_companies(
95    accounts, api_key, matching_direction="domain_to_linkedin"
96)
97print(json.dumps(match_results, indent=2))

Kør det med:

1python find_linkedin_company_pages.py

Funktionen foretager tre typer API-kald i en fast rækkefølge.

Først sender POST-kaldet de fem websites med matchingDirection sat til domain_to_linkedin. API'et svarer med 202 Accepted og et opgave-ID, fordi matchingen kører som en baggrundsopgave. Requests-scriptet opleves stadig som sekventielt, fordi det venter, før det går videre til næste trin.

1response = requests.post(tasks_url, headers=headers, json=payload)
2response.raise_for_status()
3task = response.json()
4task_id = task["@id"]

Dernæst kontrollerer status-requestet opgaven, indtil dens status bliver completed, failed eller stopped. Pausen på tre sekunder forhindrer scriptet i at sende status-requests konstant.

Til sidst henter resultat-requestet sider med op til 100 resultater ad gangen. Hvis nextCursor indeholder en værdi, sender loopet den som cursor i næste request. Det stopper først, når nextCursor er null.

Læs matches, og afgør, hvad der skal kontrolleres

Her er den komplette resultatliste for de fem input:

[
  {
    "inputId": "account-datablist",
    "status": "success",
    "outputs": {
      "companyWebsite": "datablist.com",
      "confidence": "high",
      "companyLinkedInUrl": "https://www.linkedin.com/company/datablist",
      "companyName": "datablist"
    },
    "creditsUsed": "1.5",
    "error": null
  },
  {
    "inputId": "account-posthog",
    "status": "success",
    "outputs": {
      "companyWebsite": "posthog.com",
      "confidence": "high",
      "companyLinkedInUrl": "https://www.linkedin.com/company/posthog",
      "companyName": "PostHog"
    },
    "creditsUsed": "1.5",
    "error": null
  },
  {
    "inputId": "account-n8n",
    "status": "success",
    "outputs": {
      "companyWebsite": "n8n.io",
      "confidence": "high",
      "companyLinkedInUrl": "https://www.linkedin.com/company/n8n",
      "companyName": "n8n"
    },
    "creditsUsed": "1.5",
    "error": null
  },
  {
    "inputId": "account-vaude",
    "status": "success",
    "outputs": {
      "companyWebsite": "vaude.com",
      "confidence": "high",
      "companyLinkedInUrl": "https://www.linkedin.com/company/vaude",
      "companyName": "vaude"
    },
    "creditsUsed": "1.5",
    "error": null
  },
  {
    "inputId": "account-drooms",
    "status": "success",
    "outputs": {
      "companyWebsite": "drooms.com",
      "confidence": "low",
      "companyLinkedInUrl": "https://www.linkedin.com/company/drooms-software",
      "companyName": "Drooms"
    },
    "creditsUsed": "1.5",
    "error": null
  }
]

Læs status og confidence hver for sig. API'et returnerer et resultatobjekt for hvert input, også når opslaget ikke lykkes. Statussen success betyder, at API'et har fundet en mulig virksomhedsside. Værdien i outputs.confidence fortæller, om website-match'et er valideret. inputId forbinder objektet med din account i kildedataene, mens creditsUsed registrerer prisen for rækken, og error indeholder strukturerede fejloplysninger, hvis der opstår en fejl.

Gem hele outputs-objektet i din applikation, selv hvis den første visning kun skal bruge LinkedIn-URL'en og confidence. companyName og companyWebsite gør manuel kontrol hurtigere, især når det returnerede virksomhedsnavn bruger andre store og små bogstaver, eller inputtet var en komplet URL. Felterne giver dig også nyttig kontekst uden endnu et API-kald.

Matchingprocessen begynder med at normalisere det indsendte website og kontrollere virksomhedsdatasæt for en kendt relation mellem websitet og LinkedIn. Derefter sammenlignes inputdomænet med det website, der er angivet på den mulige LinkedIn-virksomhedsside. Et match på det registrerede domæne giver high confidence.

Når datasættene ikke indeholder en LinkedIn-URL, kan opslaget foretage en målrettet Google-søgning efter mulige virksomhedssider. En kandidat, der ikke kan valideres mod et offentliggjort website, kan blive returneret med low confidence. Et kendt mismatch mellem websites accepteres ikke.

Brug confidence som en anvisning til kontrol. VAUDE returnerede https://www.linkedin.com/company/vaude med high confidence og kan derfor føjes til research-køen. Drooms returnerede https://www.linkedin.com/company/drooms-software med low confidence. Åbn Drooms' website og LinkedIn-side, før du stoler på denne relation.

Datablist, PostHog og n8n gav også matches med høj confidence. API'et finder relationen mellem websitet og virksomhedssiden. Hvis du efter kontrollen af URL'en har brug for virksomhedsstørrelse, branche eller andre sidedata, kan du fortsætte med guiden til LinkedIn company scraper API.

Opret en kø til account research fra resultaterne

Genbrug nu match_results til at oprette en lokal kø til manuel virksomhedsresearch. Denne kodeblok kalder ikke API'et igen. Den indekserer resultaterne efter inputId og gennemgår derefter den oprindelige account-liste, så alle accounts i kildedataene forbliver synlige, selv hvis et fremtidigt resultat mangler.

1results_by_id = {result["inputId"]: result for result in match_results}
2ready_for_research = []
3needs_review = []
4
5for account in accounts:
6    result = results_by_id.get(account["account_id"])
7    if result is not None:
8        outputs = result.get("outputs", {})
9    else:
10        outputs = {}
11
12    research_record = {
13        **account,
14        "companyLinkedInUrl": outputs.get("companyLinkedInUrl"),
15        "confidence": outputs.get("confidence"),
16        "api_result": result,
17    }
18
19    is_ready = (
20        result is not None
21        and result["status"] == "success"
22        and outputs.get("companyLinkedInUrl")
23        and outputs.get("confidence") == "high"
24    )
25    if is_ready:
26        ready_for_research.append(research_record)
27    else:
28        needs_review.append(research_record)
29
30print("Ready for research:")
31print(json.dumps(ready_for_research, indent=2))
32print("Needs review:")
33print(json.dumps(needs_review, indent=2))

Resultat-dictionaryen gør sammenkædningen uafhængig af svarrækkefølgen. account-vaude forbinder den oprindelige post med vaude.com til den fundne VAUDE-side og føjes til ready_for_research. account-drooms beholder både sin komplette input-URL og hele API-resultatet, men føjes til needs_review, fordi confidence er lav, selvom resultatets status er success.

Den samme logik bevarer en manglende række eller en række med no_result eller fejl i kontrolkøen. De to udskrevne lister giver teamet et klart udgangspunkt for manuel virksomhedsresearch.

Du kan også downloade det vedligeholdte synkrone Requests-eksempel. Repositoriet indeholder desuden et asynkront HTTPX-eksempel til applikationer, der har brug for non-blocking HTTP. Den blokerende version ovenfor er dog lettere at følge i din første integration.

Find websitet ud fra en LinkedIn-virksomhedsside

Den samme funktion accepterer LinkedIn-virksomhedssider, når du ændrer matchingretningen. Det er nyttigt, hvis din kildeliste indeholder URL'er til virksomhedssider, og du skal bruge websites før en kompatibel virksomheds- eller arbejdsmail-enrichment.

1linkedin_accounts = [
2    {
3        "account_id": "account-datablist",
4        "company_name": "Datablist",
5        "source_url": "https://www.linkedin.com/company/datablist",
6    }
7]
8
9website_results = match_companies(
10    linkedin_accounts,
11    api_key,
12    matching_direction="linkedin_to_domain",
13)

Et almindeligt opslag på en LinkedIn-virksomhedsside bruger den normale matchingpris. Numeriske virksomheds-ID'er og Sales Navigator-virksomheds-URL'er kan koste 10 credits, fordi de følger en anden reverse lookup-proces. Se sådan finder du website-URL'er fra LinkedIn-virksomhedssider, hvis du vil bruge denne retning uden kode.

Beregn credits til website-to-LinkedIn-opslag

Et vellykket, almindeligt website-to-LinkedIn-opslag bruger 1,5 credits. De fem viste matches brugte derfor 7,5 credits. Med samme pris bruger 1.000 vellykkede matches 1.500 credits. Ugyldige input og rækker uden resultat kan bruge nul credits, så kontrollér værdien creditsUsed i hvert resultat for at se det faktiske forbrug.

Adgang til REST API er en del af Growth-abonnementet, og månedsabonnementet er adskilt fra top-up credits. En top-up til 20 USD giver 20.000 credits, så én credit koster 0,001 USD. Ved 1,5 credits pr. vellykket match bruger 1.000 matches 1.500 credits til en værdi af 1,50 USD. Se Datablists priser for aktuelle abonnementer og pakker.

Løs typiske problemer med input, opgaver og resultater

• DATABLIST_API_KEY mangler: Scriptet stopper, før det sender et request. Eksportér miljøvariablen, og kør kommandoen igen.
• API'et afviser nøglen: Kontrollér, at du har kopieret en Personal API Key, og at requestet kun sender den i X-API-Key.
• Inputtet understøttes ikke: Brug et virksomhedswebsite eller domæne til domain_to_linkedin. I den modsatte retning skal du bruge en understøttet URL til en virksomhedsside frem for en personlig profil eller en tom værdi.
• Der er ikke nok credits: Kontrollér din saldo, og brug derefter inkluderede credits, eller køb en top-up, før du opretter en ny opgave.
• Opgaven har statussen failed eller stopped: Undersøg opgavens status, fejl, eksisterende resultater og creditforbrug, før du beslutter, om den skal indsendes igen.
• Et resultat har lav confidence, no_result eller en fejl: Bevar kildewebsitet og hele resultatet i needs_review. Åbn den mulige side, hvis den findes, og gæt ikke på, hvorfor et resultat mangler.

Hvis forbindelsen afbrydes under oprettelsen af opgaven, skal du bruge det uniqueId, der blev udskrevet før POST-kaldet. Hent din opgaveliste, og søg efter værdien, før du opretter en ny opgave:

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

Opgavelisten kan ikke filtreres efter uniqueId, så gennemgå hver returneret opgave, og følg om nødvendigt nextCursor. Når du har fundet den matchende værdi, bruger du dens @id med de samme status- og resultat-URL'er som i scriptet.

Én opgave kan indeholde op til 10.000 input. Du finder alle grænser for requests, opbevaring af opgaver og paginering i dokumentationen til Company to LinkedIn API.

Næste skridt

Du har nu én genanvendelig Python Requests-funktion, der omdanner virksomhedswebsites til mulige LinkedIn-virksomhedssider. Den lokale kø holder matches med høj confidence klar til research og sikrer, at usikre eller mislykkede poster fortsat er synlige til kontrol.

Erstat de fem eksempler med en mindre account-liste, kontrollér alle kandidater med lav confidence, og brug derefter de godkendte URL'er til manuel virksomhedsresearch eller som input til LinkedIn company scraper API. Hvis din kildeliste indeholder virksomhedsnavne i stedet for websites, kan du begynde med guiden til Company Website Finder API.