Trouver le site d’une entreprise avec Python et une API

Pour trouver le site web d’une entreprise à partir de son nom en Python, envoyez son nom et, si vous le connaissez, son pays à l’API Company Name to Domain de Datablist. L’API traite la recherche en arrière-plan, puis renvoie le domaine et l’URL complète du site.

Je vais d’abord vous montrer une requête API Python simple. Nous réutiliserons ensuite la même fonction pour compléter uniquement les sites manquants dans une liste d’entreprises, sans modifier les URL déjà renseignées.

Si vous préférez une interface proche d’un tableur, consultez le guide pour trouver en masse le site d’une entreprise à partir de son nom.

💡 Résumé pour les plus pressés

Créez une fonction Python qui trouve un site à partir du nom d’une entreprise, puis utilisez-la pour compléter les fiches dont le champ site web est vide, sans remplacer les URL connues.

• Entrée : noms d’entreprises, avec le pays si disponible.
• Sortie : domaine, URL complète du site, niveau de confiance, statut du résultat et crédits consommés.

Configurer Python et votre clé API Datablist

Pour cet exemple, j’utilise le package Requests afin d’effectuer des appels HTTP synchrones. Installez-le dans un environnement virtuel :

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

Vous devez également disposer d’un abonnement Datablist Growth, car l’accès à la REST API fait partie de cette offre. Créez une Personal API Key depuis la page API de votre compte Datablist, puis enregistrez-la dans une variable d’environnement :

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

🔑 Vous avez déjà une clé API ? Les anciennes clés utilisent le format auth0|<userId>:<accountId>:<secret>:1. Elles restent compatibles. Continuez à utiliser votre clé existante exactement telle qu’elle a été générée : vous n’avez pas besoin de la remplacer ni d’en modifier le format.

Remplacez la valeur d’exemple ci-dessus par la clé générée sur la page de votre compte. Les recherches de sites d’entreprises consomment des crédits. Avant de passer à l’échelle, je vous explique les deux scénarios, à 1 crédit et à 2,5 crédits. Les tarifs à jour sont disponibles sur la page des tarifs Datablist.

Trouver le site d’une entreprise avec Python

Créez un fichier nommé find_company_websites.py. Le script envoie les noms, attend la fin de la tâche et récupère les résultats dans une seule fonction. Pour chaque entrée, il utilise l’identifiant stable de votre fiche comme inputId. Vous pouvez ainsi rattacher chaque résultat à la bonne entreprise, même si l’ordre de la réponse change.

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

Exécutez-le depuis le terminal dans lequel vous avez exporté la clé :

1python find_company_websites.py

Voici le résultat obtenu pour Microsoft :

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

Utilisez inputId pour rattacher ce résultat à la fiche d’origine. status peut prendre les valeurs success, no_result, error ou skipped. Un résultat positif peut contenir companyDomain, l’URL complète companyUrl et domainConfidence. creditsUsed indique le coût de cette entrée, tandis que error décrit une erreur propre à l’élément.

La fonction effectue successivement trois types d’appels API.

Elle envoie d’abord la recherche. Le payload contient les paramètres et les fiches d’entreprises. La requête POST renvoie 202 Accepted, et @id correspond à l’identifiant de tâche requis pour les appels suivants :

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

Si DATABLIST_API_KEY n’est pas définie, Python lève une exception KeyError lors de la lecture de l’environnement, avant même d’envoyer une requête HTTP. Exportez la variable, puis relancez le script. Si elle contient une clé invalide, la requête POST atteint l’API et renvoie une erreur HTTP 401. Copiez une Personal API Key valide depuis la page de votre compte et remplacez la valeur incorrecte.

Elle vérifie ensuite l’état de la tâche. La requête POST lance un traitement en arrière-plan. Le script consulte donc la tâche toutes les trois secondes jusqu’à ce qu’elle passe au statut completed, failed ou 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)

Si la tâche échoue faute de crédits, son erreur contient le motif credits_error. Ajoutez des crédits ou attendez le renouvellement de votre quota mensuel, examinez les éventuels résultats déjà renvoyés, puis soumettez uniquement les entrées non traitées dans une nouvelle tâche.

Enfin, elle récupère toutes les pages de résultats. Chaque réponse ajoute des résultats à la liste et fournit le curseur nécessaire à la requête suivante :

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

Le script récupère les pages suivantes jusqu’à ce que nextCursor soit égal à null.

Avant la requête POST, le script affiche le uniqueId généré. Si la connexion est interrompue avant la réception de la réponse de création, commencez par lister vos tâches et vérifier leur statut 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-name-to-domain"

Repérez la tâche dont le uniqueId correspond à la valeur générée par le script, puis copiez son @id. L’endpoint de liste permet de filtrer par enrichmentId, mais pas par uniqueId. Utilisez cet @id avec les mêmes URL de statut et de résultats que le script. Si la tâche est toujours active, continuez à vérifier son état. Si elle est arrêtée ou a échoué, recherchez d’éventuels résultats partiels avant de renvoyer les entrées.

Comprendre le matching et le fallback par pays

Le script utilise dataset_google, le réglage recommandé par défaut. Datablist vérifie d’abord ses datasets d’entreprises. Si aucun match n’est trouvé ou si les données se contredisent, Google peut servir de fallback. Les correspondances possibles sont contrôlées avant l’attribution d’un niveau de confiance.

Le pays aide à départager les noms ambigus. Dans cet exemple, le même nom d’entreprise a produit deux résultats différents :

• Mercury avec US a renvoyé shipmercury.com et https://www.shipmercury.com/.
• Mercury avec IE a renvoyé mercuryeng.com et http://www.mercuryeng.com.

Les deux résultats avaient un niveau de confiance High. Le pays permet à la recherche de distinguer plusieurs entreprises portant le même nom, tandis que le niveau de confiance vous aide à identifier les résultats qui nécessitent une vérification.

Lorsque le matching dépend également du secteur, de la taille de l’entreprise ou d’autres informations métier, utilisez le workflow de recherche AI Agent. Ajoutez ces précisions au prompt de l’AI Agent afin qu’il puisse rechercher l’entreprise visée avec davantage de contexte.

Compléter uniquement les sites web manquants

Maintenant que find_domains() sait trouver un site à partir du nom d’une entreprise, réutilisez cette fonction pour compléter uniquement les sites absents de vos fiches. Les fiches qui possèdent déjà un site ne sont pas envoyées à l’API : leur valeur reste donc inchangée et elles ne consomment aucun crédit de recherche.

Dans find_company_websites.py, remplacez tout le contenu compris entre companies = [ et la dernière boucle d’affichage par le bloc ci-dessous. Conservez l’affectation api_key qui le précède. La vérification des champs vides couvre None, les chaînes vides et les espaces. Aucun appel API n’est effectué si tous les sites sont renseignés.

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

Le code indexe les résultats par inputId, puis parcourt les fiches d’origine dans leur ordre initial. L’objet website_lookup conserve le résultat et les informations nécessaires à sa vérification à côté de chaque fiche traitée, y compris en cas d’échec ou de résultat manquant.

Pour crm-001, website_is_missing() renvoie False, car l’URL de Microsoft est déjà présente. La fiche n’est pas ajoutée à records_to_lookup et n’est donc jamais envoyée à l’API. La fusion conserve son site et enregistre le statut not_requested.

Pour crm-002, le champ site web est vide. La requête envoie donc la boulangerie avec inputId: crm-002. L’API renvoie le même inputId, que results_by_id utilise pour retrouver le bon résultat. La fusion ajoute alors https://boulangerie-du-palais-lyon.eatbu.com à cette fiche sans dépendre de l’ordre des résultats.

La boulangerie utilise un sous-domaine propre à son activité : boulangerie-du-palais-lyon.eatbu.com. Conservez cette valeur au lieu de la réduire à eatbu.com, et enregistrez l’adresse exacte fournie par companyUrl. Le paramètre acceptNonRoot: true autorise également les pages professionnelles hébergées dont l’adresse contient un chemin après le nom d’hôte. Dans les deux cas, l’URL complète est donc importante.

Une tâche terminée peut tout de même contenir des éléments no_result, error ou skipped. L’exemple ne modifie website que si le statut est success et que companyUrl est présent. En cas de no_result, le site reste vide et le statut demeure visible dans website_lookup. Commencez par vérifier le nom et le pays de l’entreprise. Si l’une de ces données est erronée, corrigez-la et renvoyez cette fiche dans une nouvelle tâche. Sinon, laissez le champ site web vide pour signaler qu’une vérification manuelle est nécessaire.

Estimer les crédits avant de passer à l’échelle

Les cinq recherches de l’exemple ont toutes renvoyé success avec un niveau de confiance High, pour un total de 5 crédits.

Une recherche résolue à partir du dataset coûte 1 crédit. Une recherche traitée avec Google coûte 2,5 crédits. Vous payez uniquement le parcours utilisé, pas les deux. Pour 1 000 entrées, comptez donc 1 000 crédits si elles sont toutes résolues par le dataset, ou 2 500 crédits si elles passent toutes par Google. Il s’agit d’estimations budgétaires, et non d’une garantie que chaque recherche aboutira.

Déplacez le curseur pour comparer la consommation de crédits correspondant à votre liste.

À 20 $ pour 20 000 crédits, ces scénarios coûtent respectivement 1 $ et 2,50 $. L’abonnement Growth est facturé séparément et comprend actuellement 20 000 crédits mensuels, consommés avant les recharges. Consultez les tarifs actuels, car les offres et les volumes de crédits peuvent évoluer.

Une tâche accepte jusqu’à 10 000 entrées, avec une limite de 16 Kio par entrée et de 10 Mio par requête. Cet exemple utilise des appels Requests bloquants pour envoyer une petite tâche Datablist asynchrone, vérifier son état et récupérer ses résultats. Le repository maintenu comprend également des exemples de traitement CSV par lots et de clients non bloquants.

Prochaines étapes

Une fois que vous avez confirmé que le site renvoyé appartient bien à l’entreprise recherchée, vous pouvez scraper ses mentions légales avec Python afin d’ajouter à la même fiche fournisseur les informations légales de l’entreprise et l’URL de la page source. Vérifiez d’abord la correspondance du site, indépendamment de l’extraction qui suivra.

Remplacez les fiches d’exemple par un petit échantillon de vos propres données, puis exécutez le script et examinez les fiches fusionnées. Conservez des identifiants stables et le pays, puis augmentez le volume uniquement après avoir vérifié que le script préserve les sites connus et complète bien les champs attendus. Vous pouvez partir des exemples maintenus de la Company Name to Domain API sur GitHub si vous souhaitez télécharger le script, traiter des CSV par lots ou utiliser une version asynchrone.