Finn LinkedIn-bedriftssider fra nettsteder med Python

Bruk Datablists Company to LinkedIn API for å finne en LinkedIn-bedriftsside fra et nettsted med Python. Du kan sende inn et rent domene eller en fullstendig nettadresse, vente på matching-oppgaven og motta bedriftsnavn, nettsted, URL til LinkedIn-bedriftssiden og et konfidensnivå.

I denne veiledningen bruker jeg Python og Requests-biblioteket til å matche fem bedriftsnettsteder. Listen inneholder kjente programvareselskaper samt VAUDE, som leverer friluftsutstyr, og Drooms, som tilbyr virtuelle datarom. Deretter deler jeg resultatene i to lokale køer: matcher som er klare for bedriftsresearch, og matcher som må kontrolleres manuelt.

🔑 Kort oppsummert for deg som har det travelt

Send nettstedene fra account-listen din til Datablists Company to LinkedIn API. API-et returnerer URL-er til LinkedIn-bedriftssider og konfidensnivåer som hjelper deg med å avgjøre hvilke koblinger du kan bruke, og hvilke du bør kontrollere.

• Input: rene domener og fullstendige URL-er til bedriftsnettsteder.
• Output: bedriftsnavn, matchede nettsteder, URL-er til LinkedIn-bedriftssider og konfidensnivået high eller low, gruppert i køene Ready for research og Needs review.

💡 Foretrekker du en no-code-løsning? Bruk Datablists LinkedIn Company Pages & Domain Lookup til å matche bedriftsnettsteder og LinkedIn-sider uten å skrive kode.

Konfigurer Python og Datablist API-nøkkelen

I dette eksempelet bruker jeg pakken requests. Selve API-et kommuniserer via HTTP, så du kan senere tilpasse den samme sekvensen av forespørsler til et annet språk.

Du trenger en Datablist-konto med tilgang til REST API, som er inkludert i Growth-abonnementet. Vellykkede oppslag bruker også enrichment credits. Den nøyaktige beregningen av credits finner du senere i veiledningen.

Opprett en arbeidsmappe og filen find_linkedin_company_pages.py. Opprett deretter 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

Opprett en Personal API Key fra Datablist-kontoen din, og eksporter den som en miljøvariabel:

1export DATABLIST_API_KEY="your-api-key"

Skriptet leser denne verdien og sender den i headeren X-API-Key.

Finn LinkedIn-bedriftssider med én Python-funksjon

Eksempelet bruker disse fem kildekontoene:

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

Hver account_id blir API-ets inputId. Dette er viktig fordi resultatene ikke nødvendigvis kommer i samme rekkefølge som input-dataene. Med en stabil ID kan du koble hvert resultat til riktig kildekonto.

Lim inn hele skriptet nedenfor 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))

Kjør det med:

1python find_linkedin_company_pages.py

Funksjonen utfører tre typer kall i denne rekkefølgen.

Først sender POST-kallet de fem nettstedene med matchingDirection satt til domain_to_linkedin. API-et svarer med 202 Accepted og en oppgave-ID fordi matchingen kjører som en bakgrunnsoppgave. Requests-skriptet oppleves likevel som sekvensielt, fordi det venter før det går videre til neste trinn.

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

Deretter kontrollerer statusforespørselen oppgaven frem til den får statusen completed, failed eller stopped. Pausen på tre sekunder hindrer skriptet i å sende statusforespørsler kontinuerlig.

Til slutt leser resultatforespørselen sider med opptil 100 resultater. Hvis nextCursor inneholder en verdi, sender løkken den som cursor i neste forespørsel. Den stopper først når nextCursor er null.

Les matchene og avgjør hva som må kontrolleres

Her er hele resultatlisten for de fem input-verdiene:

[
  {
    "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
  }
]

Les status og confidence hver for seg. API-et returnerer et resultatobjekt for hver input, også for input som ikke gir treff. Statusen success betyr at API-et fant en mulig bedriftsside. Verdien i outputs.confidence forteller om koblingen til nettstedet ble validert. inputId knytter objektet til kildekontoen, mens creditsUsed registrerer kostnaden for raden og error inneholder strukturerte feildata hvis noe går galt.

Behold hele outputs-objektet i applikasjonen, selv om det første skjermbildet bare trenger LinkedIn-URL-en og konfidensnivået. companyName og companyWebsite gjør en manuell kontroll raskere, særlig når bedriftsnavnet har en annen bruk av store og små bokstaver, eller input-verdien var en fullstendig URL. Feltene gir deg også nyttig kontekst uten et nytt API-kall.

Matchingen begynner med å normalisere nettstedet som er sendt inn, og kontrollere bedriftsdatasett for en kjent kobling mellom nettstedet og LinkedIn. Deretter sammenlignes input-domenet med nettstedet som er publisert på den aktuelle LinkedIn-bedriftssiden. Et samsvar mellom registrerte domener gir high confidence.

Når datasettene ikke inneholder en LinkedIn-URL, kan oppslaget gjøre et målrettet Google-søk etter mulige bedriftssider. En kandidat som ikke kan valideres mot et publisert nettsted, kan returneres med low confidence. En kjent konflikt mellom nettsteder blir ikke godtatt.

Bruk konfidensnivået som en instruksjon for videre kontroll. VAUDE returnerte https://www.linkedin.com/company/vaude med high confidence og kan derfor legges i research-køen. Drooms returnerte https://www.linkedin.com/company/drooms-software med low confidence. Åpne nettstedet til Drooms og LinkedIn-siden før du stoler på denne koblingen.

Datablist, PostHog og n8n ga også matcher med høy confidence. Dette API-et finner koblingen mellom nettstedet og bedriftssiden. Hvis du trenger bedriftsstørrelse, bransje eller andre sidedata etter at du har kontrollert URL-en, kan du fortsette med veiledningen for LinkedIn company scraper API.

Lag en kø for account research fra resultatene

Bruk nå match_results på nytt for å lage en lokal kø for manuell bedriftsresearch. Denne kodeblokken kaller ikke API-et på nytt. Den indekserer resultatene etter inputId og går deretter gjennom den opprinnelige account-listen, slik at alle kildekontoer fortsatt er synlige selv om et fremtidig resultat skulle mangle.

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

Resultatordboken gjør koblingen uavhengig av rekkefølgen i svaret. account-vaude kobler den opprinnelige posten for vaude.com til VAUDE-siden som ble funnet, og legges i ready_for_research. account-drooms beholder både hele input-URL-en og hele API-resultatet, men legges i needs_review fordi confidence er lav, selv om resultatstatusen er success.

Den samme logikken beholder en manglende rad eller en rad med no_result eller feil i kontrollkøen. De to utskrevne listene gir teamet et tydelig utgangspunkt for manuell bedriftsresearch.

Du kan også laste ned det vedlikeholdte synkrone Requests-eksempelet. Repositoryet inneholder et asynkront HTTPX-eksempel for applikasjoner som trenger ikke-blokkerende HTTP, men den blokkerende versjonen ovenfor er enklere å følge i en første integrasjon.

Finn nettstedet fra en LinkedIn-bedriftsside

Den samme funksjonen godtar LinkedIn-bedriftssider når du endrer matching-retningen. Dette er nyttig når kildelisten inneholder URL-er til bedriftssider og du trenger nettsteder før en kompatibel company- eller work email-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 standardoppslag fra en LinkedIn-bedriftsside bruker den ordinære matching-prisen. Numeriske bedrifts-ID-er og Sales Navigator-bedrifts-URL-er kan koste 10 credits fordi de følger en annen reverse lookup-prosess. For en no-code-versjon av denne retningen kan du lese slik finner du nettadresser fra LinkedIn-bedriftssider.

Beregn credits for nettsted-til-LinkedIn-oppslag

Et vellykket, ordinært nettsted-til-LinkedIn-oppslag bruker 1,5 credits. De fem viste matchene brukte derfor 7,5 credits. Med samme pris bruker 1 000 vellykkede matcher 1 500 credits. Ugyldige input-verdier og rader uten resultat kan bruke null credits, så kontroller creditsUsed i hvert resultat for å se det faktiske forbruket.

Tilgang til REST API er inkludert i Growth-abonnementet, og månedsabonnementet er separat fra ekstra credits. En top-up på 20 USD gir 20 000 credits, så én credit koster 0,001 USD. Med 1,5 credits per vellykkede match bruker 1 000 matcher 1 500 credits til en verdi av 1,50 USD. Se Datablists priser for gjeldende abonnementer og pakker.

Løs vanlige problemer med input, oppgaver og resultater

• DATABLIST_API_KEY mangler: Skriptet stopper før det sender en forespørsel. Eksporter miljøvariabelen og kjør kommandoen på nytt.
• API-et avviser nøkkelen: Kontroller at du kopierte en Personal API Key, og at forespørselen bare sender den i X-API-Key.
• Input-verdien støttes ikke: Bruk et bedriftsnettsted eller domene for domain_to_linkedin. For motsatt retning må du bruke en støttet URL til en bedriftsside, ikke en personlig profil eller tom verdi.
• Du har for få credits: Kontroller saldoen, og bruk deretter inkluderte credits eller kjøp en top-up før du oppretter en ny oppgave.
• Oppgaven har statusen failed eller stopped: Kontroller oppgavestatusen, feilen, eksisterende resultater og credit-forbruket før du avgjør om du skal sende inn oppgaven på nytt.
• Et resultat har lav confidence, no_result eller feil: Behold kildenettstedet og hele resultatet i needs_review. Åpne kandidatsiden hvis den finnes, og ikke gjett hvorfor et resultat mangler.

Hvis forbindelsen brytes mens oppgaven opprettes, bruker du uniqueId som ble skrevet ut før POST-kallet. Hent oppgavelisten og se etter denne verdien før du oppretter en ny oppgave:

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"

Oppgavelisten kan ikke filtreres etter uniqueId, så kontroller hver returnerte oppgave og følg nextCursor ved behov. Når du finner riktig verdi, bruker du oppgavens @id med de samme URL-ene for status og resultater som i skriptet.

Én oppgave kan inneholde opptil 10 000 input-verdier. Du finner alle grenser for forespørsler, oppbevaring av oppgaver og paginering i dokumentasjonen for Company to LinkedIn API.

Neste steg

Du har nå én gjenbrukbar Python Requests-funksjon som gjør bedriftsnettsteder om til kandidater for LinkedIn-bedriftssider. Den lokale køen holder matcher med høy confidence klare for research, samtidig som usikre eller mislykkede poster forblir synlige for kontroll.

Bytt ut de fem eksemplene med en liten account-liste, kontroller alle kandidater med lav confidence, og bruk deretter godkjente URL-er til manuell bedriftsresearch eller som input til LinkedIn company scraper API. Hvis kildelisten inneholder bedriftsnavn i stedet for nettsteder, begynner du med veiledningen for company website finder API.