How to Find Company Websites from Company Names in Python Using an API

To find a company website from a company name in Python, send the name and any available country context to Datablist's Company Name to Domain API. The API processes the lookup in the background, then returns the domain and full website URL.

I will first show you a simple Python API request. Then I will reuse the same function to fill only the missing websites in a list of company records while preserving the URLs already present.

If you prefer a spreadsheet-like interface, follow the bulk company name to website guide.

💡 Summary For Those In a Rush

Build one Python function that finds websites from company names, then use it to complete records with blank websites without replacing known URLs.

• Input: company names with optional country context.
• Output: domain, full website URL, confidence, result status, and credits used.

Set up Python and your Datablist API key

For this example, I use the Requests package to make synchronous HTTP calls. Install it in a virtual environment:

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

You also need a Datablist Growth plan because REST API access is a Growth feature. Create a Personal API Key from your Datablist API account page, then put it in an environment variable:

1export DATABLIST_API_KEY="auth0|exampleuser:exampleaccount:EXAMPLE_TOKEN_NOT_VALID:1"

Replace the sample value above with the key generated on your account page. Company website lookups consume credits. I explain the 1-credit and 2.5-credit paths before scaling the script, and current plan values are on the Datablist pricing page.

Run one company website lookup in Python

Create a file named find_company_websites.py. The script submits the names, waits for the task, and fetches the results in one function. Each input uses your stable record ID as inputId, so you can match every result to the right record even if the response order changes.

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

Run it from the terminal where you exported the key:

1python find_company_websites.py

Here is the Microsoft result:

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

Use inputId to match this result to the original record. status is success, no_result, error, or skipped. A successful result can include companyDomain, the full companyUrl, and domainConfidence. creditsUsed shows the charge for this input, while error explains an item-level failure.

The function makes three types of API calls in order.

First, it submits the lookup. The payload contains the settings and company records. The POST returns 202 Accepted, and @id is the task ID needed by the next calls:

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

If DATABLIST_API_KEY is not set, Python raises KeyError at the environment lookup before making an HTTP request. Export the variable, then run the script again. If the variable contains an invalid key, the POST reaches the API and returns HTTP 401. Copy a current Personal API Key from your account page and replace the invalid value.

Second, it polls the task. The POST starts background work, so the script reads the task every three seconds until it reaches completed, failed, or 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)

If the task fails because credits are unavailable, its error has the reason credits_error. Add credits or wait for your monthly credits to renew, inspect any results already returned, then submit only the unfinished inputs in a new task.

Third, it retrieves every result page. Each response adds results to the list and supplies the cursor for the next request:

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

It fetches the next page until nextCursor is null.

The script prints the generated uniqueId before the POST. If the connection drops before you receive the creation response, list your tasks first to check their status before creating another task:

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"

Find the task whose uniqueId matches the value generated by the script, then copy its @id. The list endpoint can filter by enrichmentId, but not by uniqueId. Use the @id with the same status and results URLs used by the script. If the task is still active, keep polling it. If it has stopped or failed, check for partial results before submitting the inputs again.

Understand dataset matching and the country-aware fallback

The script uses dataset_google, the recommended default. Datablist checks its company datasets first. If the match is missing or conflicting, it can use Google as a fallback. It checks possible matches before returning a confidence level.

Country context helps with ambiguous names. In this example, the same company name produced different results:

• Mercury with US returned shipmercury.com and https://www.shipmercury.com/.
• Mercury with IE returned mercuryeng.com and http://www.mercuryeng.com.

Both had High confidence. Country context helps the lookup choose between companies with the same name, while confidence helps you decide which results need review.

When the match also depends on industry, company size, or other business context, use the AI Agent research workflow. Add those details to the AI Agent prompt so it can research the intended company with richer business context.

Fill only the missing websites in your application records

Now that find_domains() can find a website from a company name, reuse it to fill only missing websites in your company records. Records that already have a website bypass the API, so their values stay unchanged and consume no lookup credits.

In find_company_websites.py, replace everything from companies = [ through the final print loop with the block below. Keep the api_key assignment above it. The blank check handles None, an empty string, and whitespace. It makes no API call when every website is filled.

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

The code indexes results by inputId, then walks through the original records in order. The website_lookup object keeps the outcome and review details next to each attempted record, including unsuccessful or missing results.

For crm-001, website_is_missing() returns False because the Microsoft URL is already present. The record is not added to records_to_lookup, so the API never receives it. The merge keeps its website and records the status as not_requested.

For crm-002, the website is blank, so the request sends the bakery with inputId: crm-002. The API returns the same inputId. results_by_id uses it to find the right result, and the merge writes https://boulangerie-du-palais-lyon.eatbu.com to that record without relying on the result order.

The bakery uses a business-specific subdomain, boulangerie-du-palais-lyon.eatbu.com. Keep that value instead of reducing it to eatbu.com, and save the exact address from companyUrl. The acceptNonRoot: true setting also allows a hosted business page whose address includes a path after the hostname, so the full URL matters in both cases.

A completed task can still contain no_result, error, or skipped items. The example changes website only when the status is success and companyUrl is present. For no_result, the website stays blank and the status remains visible in website_lookup. Check the company name and country first. If either input is wrong, correct it and submit that record in a new task. Otherwise, keep the blank website visible for manual review.

Estimate lookup credits before scaling the script

The five example lookups all returned success with High confidence and used 5 credits total.

A lookup resolved from the dataset costs 1 credit. A lookup processed with Google costs 2.5 credits. You pay for the path used, not both. For 1,000 inputs, that means 1,000 credits if all resolve through the dataset or 2,500 credits if all use Google. These are planning scenarios, not a promise that every lookup will succeed.

At $20 for 20,000 credits, those scenarios cost $1 and $2.50. The Growth subscription is separate and currently includes 20,000 monthly credits, which are used before top-ups. Check current pricing because plan and package values can change.

One task accepts up to 10,000 inputs, with a 16 KiB limit per input and 10 MiB per request. This example uses blocking Requests calls to submit, poll, and fetch results from one small asynchronous Datablist task. The maintained repository also includes CSV batching and non-blocking client examples.

Next steps

Replace the sample records with a small slice of your own data, then run the script and inspect the merged records. Keep stable IDs and country context, and scale up only after the script preserves known websites and fills the expected blanks. You can start from the maintained Company Name to Domain API examples on GitHub if you want the downloadable script, CSV batching, or an asynchronous version.