Trouver une page LinkedIn depuis un site avec Python

Utilisez l’API Company to LinkedIn de Datablist pour trouver la page LinkedIn d’une entreprise à partir de son site web avec Python. Vous pouvez envoyer un domaine seul ou l’URL complète d’un site, attendre la fin de la tâche de matching, puis récupérer le nom de l’entreprise, son site, l’URL de sa page LinkedIn et un indice de confiance.

Dans ce guide, j’utilise Python et la bibliothèque Requests pour identifier les pages LinkedIn de cinq entreprises à partir de leur site. La liste comprend des éditeurs de logiciels connus, mais aussi VAUDE, une entreprise d’équipements outdoor, et Drooms, un fournisseur de data rooms virtuelles. Je transforme ensuite les résultats en deux files locales : les correspondances prêtes pour la recherche sur les entreprises et celles qui nécessitent une vérification manuelle.

🔑 L’essentiel si vous êtes pressé

Envoyez les sites web de votre liste de comptes à l’API Company to LinkedIn de Datablist. L’API renvoie les URL des pages LinkedIn d’entreprise et des indices de confiance pour vous aider à déterminer les correspondances exploitables et celles à vérifier.

• Entrée : domaines seuls et URL complètes de sites d’entreprise.
• Sortie : noms d’entreprise, sites correspondants, URL des pages LinkedIn et niveau de confiance high ou low, répartis entre les files Ready for research et Needs review.

💡 Vous préférez une solution no-code ? Utilisez l’enrichissement LinkedIn Company Pages & Domain Lookup de Datablist pour faire correspondre sites d’entreprise et pages LinkedIn sans écrire de code.

Configurer Python et votre clé API Datablist

Pour cet exemple, j’utilise le package requests. L’API fonctionne en HTTP : vous pourrez donc reprendre la même séquence de requêtes dans un autre langage par la suite.

Vous avez besoin d’un compte Datablist avec un accès à la REST API, disponible avec le plan Growth. Chaque recherche réussie consomme également des crédits d’enrichissement. Le calcul précis est détaillé plus loin dans ce guide.

Créez un répertoire de travail et un fichier nommé find_linkedin_company_pages.py, puis créez un environnement virtuel et installez 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

Créez une Personal API Key depuis votre compte Datablist, puis exportez-la comme variable d’environnement :

1export DATABLIST_API_KEY="your-api-key"

Le script lit cette valeur et l’envoie dans le header X-API-Key.

Trouver des pages LinkedIn avec une fonction Python

L’exemple utilise ces cinq comptes sources :

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

Chaque account_id devient l’inputId de l’API. C’est important, car les résultats ne sont pas nécessairement renvoyés dans le même ordre que les données d’entrée. Un identifiant stable permet de rattacher chaque résultat au bon compte source.

Collez le script complet suivant dans 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))

Exécutez-le avec :

1python find_linkedin_company_pages.py

La fonction effectue successivement trois types d’appels.

Tout d’abord, le POST envoie les cinq sites avec matchingDirection défini sur domain_to_linkedin. L’API répond avec le statut 202 Accepted et un ID de tâche, car le matching s’exécute en arrière-plan. Le script Requests reste toutefois simple à suivre : il attend la fin de chaque étape avant de passer à la suivante.

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

Ensuite, la requête de statut vérifie la tâche jusqu’à ce qu’elle passe à completed, failed ou stopped. La pause de trois secondes évite que le script n’envoie des requêtes de statut en continu.

Enfin, la requête de résultats récupère des pages contenant jusqu’à 100 résultats. Si nextCursor contient une valeur, la boucle l’envoie comme cursor dans la requête suivante. Elle ne s’arrête que lorsque nextCursor vaut null.

Analyser les correspondances et les résultats à vérifier

Voici la liste complète des résultats pour les cinq entrées :

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

Interprétez status et confidence séparément. L’API renvoie un objet de résultat pour chaque entrée, y compris en cas d’échec. Un statut success signifie qu’elle a trouvé une page d’entreprise candidate. La valeur outputs.confidence indique si la correspondance avec le site a pu être validée. inputId relie l’objet à votre compte source, tandis que creditsUsed indique le coût de la ligne et qu’error contient une erreur structurée le cas échéant.

Conservez l’intégralité de l’objet outputs dans votre application, même si le premier écran n’affiche que l’URL LinkedIn et le niveau de confiance. companyName et companyWebsite accélèrent la vérification manuelle, notamment lorsque la casse du nom renvoyé diffère ou que l’entrée était une URL complète. Ces champs vous apportent aussi un contexte utile sans appel API supplémentaire.

Le processus de matching commence par normaliser le site soumis et par rechercher dans les bases de données d’entreprises une relation connue entre ce site et une page LinkedIn. Il compare ensuite le domaine saisi avec le site publié sur la page LinkedIn candidate. Si les domaines enregistrés correspondent, le niveau de confiance est high.

Lorsque les bases de données ne fournissent aucune URL LinkedIn, la recherche peut lancer une requête Google ciblée pour trouver des pages d’entreprise candidates. Si une page candidate ne peut pas être validée à partir d’un site publié, elle peut être renvoyée avec un niveau de confiance low. En revanche, une incompatibilité connue entre les sites n’est pas acceptée.

Considérez le niveau de confiance comme une consigne de vérification. Pour VAUDE, l’API a renvoyé https://www.linkedin.com/company/vaude avec une confiance high : la correspondance peut donc rejoindre la file de recherche. Pour Drooms, elle a renvoyé https://www.linkedin.com/company/drooms-software avec une confiance low. Ouvrez le site de Drooms et sa page LinkedIn avant de vous fier à cette relation.

Datablist, PostHog et n8n ont également obtenu des correspondances à forte confiance. Cette API établit la relation entre le site et la page d’entreprise. Si vous avez ensuite besoin de l’effectif, du secteur ou d’autres informations issues de cette page, poursuivez avec le guide de l’API LinkedIn company scraper.

Préparer une file de recherche sur les comptes

Réutilisez maintenant match_results pour créer une file locale destinée à la recherche manuelle sur les entreprises. Ce bloc ne rappelle pas l’API. Il indexe les résultats par inputId, puis parcourt la liste de comptes d’origine afin que chaque compte source reste visible, même si un résultat venait à manquer.

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

Le dictionnaire de résultats rend la jointure indépendante de l’ordre de réponse. account-vaude relie l’enregistrement vaude.com d’origine à la page VAUDE trouvée et rejoint ready_for_research. account-drooms conserve son URL d’entrée complète et l’intégralité du résultat API, mais rejoint needs_review, car le niveau de confiance est faible malgré le statut success.

La même logique maintient dans la file de vérification toute ligne absente, avec le statut no_result ou en erreur. Les deux listes affichées donnent à l’équipe un point de départ clair pour ses recherches manuelles sur les entreprises.

Vous pouvez également télécharger l’exemple synchrone avec Requests, maintenu à jour. Le dépôt comprend aussi un exemple asynchrone avec HTTPX pour les applications qui ont besoin de requêtes HTTP non bloquantes. La version bloquante ci-dessus reste toutefois plus facile à suivre pour une première intégration.

Retrouver un site depuis une page LinkedIn d’entreprise

La même fonction accepte les pages LinkedIn d’entreprise lorsque vous changez le sens du matching. C’est utile si votre liste source contient des URL de pages d’entreprise et que vous avez besoin des sites avant de lancer un enrichissement compatible sur les entreprises ou les emails professionnels.

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)

Une recherche standard à partir d’une page LinkedIn d’entreprise utilise le tarif de matching habituel. Les identifiants numériques d’entreprise et les URL d’entreprise Sales Navigator peuvent consommer 10 crédits, car ils suivent un autre processus de reverse lookup. Pour effectuer cette opération sans code, consultez le guide expliquant comment obtenir les URL de sites depuis des pages LinkedIn d’entreprise.

Estimer les crédits pour la recherche LinkedIn

Une recherche standard et réussie d’un site vers LinkedIn consomme 1,5 crédit. Les cinq correspondances présentées ont donc utilisé 7,5 crédits. Au même tarif, 1 000 correspondances réussies consomment 1 500 crédits. Les entrées invalides et les lignes sans résultat peuvent ne consommer aucun crédit : consultez la valeur creditsUsed de chaque résultat pour connaître l’utilisation réelle.

L’accès à la REST API est inclus dans le plan Growth, et l’abonnement mensuel est distinct des crédits supplémentaires. Une recharge de 20 $ vous donne 20 000 crédits, soit 0,001 $ par crédit. À raison de 1,5 crédit par correspondance réussie, 1 000 correspondances utilisent 1 500 crédits, d’une valeur de 1,50 $. Consultez les tarifs Datablist pour connaître les offres et packs actuels.

Résoudre les problèmes d’entrée, de tâche et de résultat

• DATABLIST_API_KEY est absente : le script s’arrête avant d’envoyer une requête. Exportez la variable d’environnement, puis relancez la commande.
• L’API refuse la clé : vérifiez que vous avez copié une Personal API Key et que la requête l’envoie uniquement dans X-API-Key.
• L’entrée n’est pas prise en charge : pour domain_to_linkedin, utilisez un site d’entreprise ou un domaine. Dans l’autre sens, utilisez l’URL compatible d’une page d’entreprise, et non un profil personnel ou une valeur vide.
• Le solde de crédits est insuffisant : vérifiez votre solde, puis utilisez les crédits inclus ou ajoutez une recharge avant de créer une nouvelle tâche.
• La tâche est failed ou stopped : examinez son statut, l’erreur, les résultats existants et les crédits consommés avant de décider de la relancer.
• Un résultat présente une confiance faible, le statut no_result ou une erreur : conservez le site source et le résultat complet dans needs_review. Ouvrez la page candidate lorsqu’elle existe et ne supposez pas la cause d’une absence de résultat.

Si la connexion est interrompue pendant la création de la tâche, utilisez le uniqueId affiché avant le POST. Listez vos tâches et recherchez cette valeur avant d’en créer une autre :

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"

La liste des tâches ne peut pas être filtrée par uniqueId. Examinez donc chaque tâche renvoyée et suivez nextCursor si nécessaire. Une fois la valeur correspondante trouvée, utilisez son @id avec les mêmes URL de statut et de résultats que dans le script.

Une tâche peut contenir jusqu’à 10 000 entrées. Pour connaître toutes les limites relatives aux requêtes, à la conservation des tâches et à la pagination, consultez la documentation de l’API Company to LinkedIn.

Prochaines étapes

Vous disposez maintenant d’une fonction Python Requests réutilisable qui transforme des sites d’entreprise en pages LinkedIn candidates. La file locale conserve les correspondances à forte confiance prêtes pour la recherche et laisse visibles les enregistrements incertains ou sans résultat afin de les vérifier.

Remplacez les cinq exemples par une petite liste de comptes, vérifiez chaque page candidate à faible confiance, puis utilisez les URL validées pour vos recherches manuelles sur les entreprises ou comme entrées de l’API LinkedIn company scraper. Si votre liste source contient des noms d’entreprise plutôt que des sites, commencez par le guide de l’API de recherche de sites d’entreprise.