In 2022, a partner handed us a CRM import with 4,000 account records. Company names only. No websites, no domains, nothing to match on.
Two interns spent a week Googling names and pasting URLs. And here’s the painful part: about 10% of what they pasted turned out to be lookalike sites, resellers, or the wrong regional domain. The email sequences we built on top of that list bounced hard.
A company name to domain API does that same job in under an hour, with a confidence score attached to every row. So let’s talk about what it is, how it works, and how to call one in seven programming languages.
What is a company name to domain API?
A company name to domain API is a REST endpoint that takes a company name and returns the company’s verified website domain. You send text, you get the official website back as structure:
"Microsoft" + country → microsoft.com + confidence score
Why does that matter? Because company names are messy. “Acme”, “Acme Inc.”, and “ACME Corporation” might all be the same business, or three different ones. A domain, on the other hand, is unique. It’s the closest thing B2B data has to a primary key, which makes it the anchor for deduplication, record matching, and every enrichment step that comes after.
Unlike a manual web search that returns ten links you have to eyeball, a name to domain API returns one structured JSON answer with a confidence level. That’s the difference between a research task and a data pipeline.
How does a name to domain API work?
Under the hood, it’s a lookup against a large database of verified company records, with matching logic layered on top. CUFinder’s endpoint, for example, resolves names against 85M+ company records.
The matching does three jobs:
- Normalization: stripping punctuation, casing, and legal suffixes (Inc, LLC, GmbH) so “Acme, Inc.” and “acme inc” resolve the same way
- Database matching: finding the verified company record behind the cleaned-up name
- Disambiguation: deciding WHICH “Apex” or “Global” you meant when several exist
That last one is the hard part. And it’s exactly why the CUFinder endpoint requires a country code with every request. The Company Name to Domain API reference uses a great example. Search “Nestlé” with the country set to Switzerland, and you get nestle.ch, not one of the dozens of regional Nestlé sites.
Here’s the thing about accuracy claims in this category. Any API can find microsoft.com for “Microsoft”. The real test is the long tail: small businesses, international firms, ambiguous names. That’s where the confidence score in each response earns its keep: it tells you which rows to trust and which rows to review.
Names are ambiguous. Domains aren’t. That’s the whole trade.
What developers actually use it for
That’s the mechanism. Here’s what people build with it:
- CRM enrichment: filling empty website fields on import, so every account record gets its company website the moment it lands
- Deduplication and lead routing: using the domain as the canonical key, so “Acme” and “Acme Inc.” stop creating duplicate accounts
- Pipeline chaining: feeding the resolved domain into Company Enrichment for full firmographics (industry, headcount, revenue)
- ABM list building: turning a spreadsheet of target company names into a match-ready account list
- Brand and logo lookups: resolving a text input to a domain so logo and metadata services have something to key on
My 2022 cleanup used the first two. And once the domain column existed, a colleague chained the same lookup into a workflow that chains this exact call into a CEO-finding workflow: domain first, decision-maker second. The domain is step one of almost everything.
The request and the response
So what does the call actually look like? The endpoint takes a form-encoded POST at https://api.cufinder.io/v2/cuf with your API key in an x-api-key header. Two attributes, both required:
company_name: the name you’re resolvingcountry_code: an ISO 3166 country code that scopes results to that country
The response is compact JSON:
{
"status": 1,
"data": {
"confidence_level": 94,
"query": "cufinder",
"domain": "http://cufinder.io/",
"credit_count": 9997
}
}Four fields worth naming: status (1 means a match), domain (your answer), confidence_level (how sure the match is), and credit_count (your remaining balance). The documented accuracy range for this endpoint is 94-98%. And each record found costs 1 credit.
📌 Remember: country_code is a REQUIRED parameter, and it scopes results to that country: 'Nestlé' + 'CH' returns nestle.ch. Omitting it is the most common integration mistake.
Now the fun part. Here’s the same call in seven languages.
Company name to domain API in Python
If you just want the answer, the official Python SDK is one line of setup and one call:
from cufinder import Cufinder
client = Cufinder('your-api-key-here')
result = client.cuf('cufinder', 'US')
print(result)But if you’re wiring this into a bulk pipeline (reading a list, pacing requests, handling failures), a small class around the requests library gives you more control. This is the bulk name to domain pattern I actually run:
import requests
import time
from typing import Optional, Dict, Any
class CompanyNameToDomainAPI:
def __init__(self, api_key: str):
self.api_key = api_key
self.base_url = "https://api.cufinder.io/v2/cuf"
self.headers = {
"Content-Type": "application/x-www-form-urlencoded",
"x-api-key": self.api_key
}
def get_company_domain(self, company_name: str,
country_code: str = "US") -> Optional[Dict[str, Any]]:
"""Look up one company's domain from its name."""
try:
data = {
"company_name": company_name,
"country_code": country_code # required
}
response = requests.post(self.base_url, headers=self.headers, data=data)
response.raise_for_status()
result = response.json()
if result.get("status") == 1:
return {
"company_name": company_name,
"domain": result["data"]["domain"],
"confidence": result["data"]["confidence_level"],
"credits_remaining": result["data"]["credit_count"]
}
print(f"No domain found for {company_name}")
return None
except requests.exceptions.RequestException as e:
print(f"Request error for {company_name}: {e}")
return None
except KeyError as e:
print(f"Response parsing error for {company_name}: {e}")
return None
def bulk_lookup(self, company_names: list,
country_code: str = "US", delay: float = 0.7) -> list:
"""Bulk name to domain lookup with rate-limit pacing."""
results = []
for company_name in company_names:
result = self.get_company_domain(company_name, country_code)
if result:
results.append(result)
time.sleep(delay) # stays under 100 requests/minute
return results
if __name__ == "__main__":
api_client = CompanyNameToDomainAPI("your-api-key-here")
company_result = api_client.get_company_domain("Microsoft", "US")
if company_result:
print(f"Domain: {company_result['domain']}")
print(f"Confidence: {company_result['confidence']}%")
companies = ["Apple", "Google", "Amazon", "Meta"]
for row in api_client.bulk_lookup(companies, "US"):
print(f"{row['company_name']}: {row['domain']} ({row['confidence']}%)")One run per country. If your list spans countries, store the country next to each name and pass it per row. Don’t guess it later.
Company name to domain API in PHP
There’s no official PHP SDK, so raw cURL is the honest pattern here, and it’s perfectly fine:
<?php
class CompanyNameToDomainAPI {
private $apiKey;
private $baseUrl = 'https://api.cufinder.io/v2/cuf';
public function __construct($apiKey) {
$this->apiKey = $apiKey;
}
public function getCompanyDomain($companyName, $countryCode = 'US') {
$curl = curl_init();
curl_setopt_array($curl, [
CURLOPT_URL => $this->baseUrl,
CURLOPT_RETURNTRANSFER => true,
CURLOPT_TIMEOUT => 30,
CURLOPT_CUSTOMREQUEST => 'POST',
CURLOPT_POSTFIELDS => http_build_query([
'company_name' => $companyName,
'country_code' => $countryCode // required
]),
CURLOPT_HTTPHEADER => [
'Content-Type: application/x-www-form-urlencoded',
'x-api-key: ' . $this->apiKey
],
]);
$response = curl_exec($curl);
$httpCode = curl_getinfo($curl, CURLINFO_HTTP_CODE);
curl_close($curl);
if ($httpCode !== 200 || $response === false) {
error_log("Name to domain API request failed for: $companyName");
return null;
}
$result = json_decode($response, true);
if ($result['status'] === 1) {
return [
'company_name' => $companyName,
'domain' => $result['data']['domain'],
'confidence' => $result['data']['confidence_level'],
'credits_remaining' => $result['data']['credit_count']
];
}
return null;
}
public function bulkLookup($companyNames, $countryCode = 'US', $delay = 0.7) {
$results = [];
foreach ($companyNames as $companyName) {
$result = $this->getCompanyDomain($companyName, $countryCode);
if ($result !== null) {
$results[] = $result;
}
usleep($delay * 1000000); // rate-limit pacing
}
return $results;
}
}
$apiClient = new CompanyNameToDomainAPI('your-api-key-here');
$companyResult = $apiClient->getCompanyDomain('Microsoft', 'US');
if ($companyResult) {
echo "Domain: " . $companyResult['domain'] . "\n";
echo "Confidence: " . $companyResult['confidence'] . "%\n";
}
$bulkResults = $apiClient->bulkLookup(['Apple', 'Google', 'Amazon'], 'US');
foreach ($bulkResults as $result) {
echo $result['company_name'] . ': ' . $result['domain'] .
' (' . $result['confidence'] . "%)\n";
}
?>Company name to domain API in Kotlin
For Android or JVM services, OkHttp plus Gson keeps it tidy, and coroutines keep it off the main thread:
import okhttp3.*
import com.google.gson.Gson
import com.google.gson.annotations.SerializedName
import java.io.IOException
import kotlinx.coroutines.*
data class APIResponse(val status: Int, val data: DomainData?)
data class DomainData(
val domain: String,
@SerializedName("confidence_level") val confidenceLevel: Int,
@SerializedName("credit_count") val creditCount: Int
)
class CompanyNameToDomainAPI(private val apiKey: String) {
private val client = OkHttpClient()
private val gson = Gson()
private val baseUrl = "https://api.cufinder.io/v2/cuf"
suspend fun getCompanyDomain(companyName: String,
countryCode: String = "US"): DomainData? {
return withContext(Dispatchers.IO) {
try {
val formBody = FormBody.Builder()
.add("company_name", companyName)
.add("country_code", countryCode) // required
.build()
val request = Request.Builder()
.url(baseUrl)
.post(formBody)
.addHeader("x-api-key", apiKey)
.build()
val response = client.newCall(request).execute()
if (!response.isSuccessful) return@withContext null
val apiResponse = gson.fromJson(
response.body?.string(), APIResponse::class.java)
if (apiResponse.status == 1) apiResponse.data else null
} catch (e: IOException) {
println("Network error for $companyName: ${e.message}")
null
}
}
}
}
fun main() = runBlocking {
val apiClient = CompanyNameToDomainAPI("your-api-key-here")
val result = apiClient.getCompanyDomain("Microsoft", "US")
result?.let {
println("Domain: ${it.domain} (${it.confidenceLevel}%)")
}
}Company name to domain API in JavaScript
In the browser or Node, the native fetch API handles it. And if you’re in a TypeScript project, the official SDK gets you there faster: @cufinder/cufinder-ts exposes the same call as await client.cuf('cufinder', 'US'). Here’s the fetch version, with both sequential and controlled-concurrency bulk lookups:
class CompanyNameToDomainAPI {
constructor(apiKey) {
this.apiKey = apiKey;
this.baseUrl = 'https://api.cufinder.io/v2/cuf';
}
async getCompanyDomain(companyName, countryCode = 'US') {
try {
const response = await fetch(this.baseUrl, {
method: 'POST',
headers: {
'Content-Type': 'application/x-www-form-urlencoded',
'x-api-key': this.apiKey
},
body: new URLSearchParams({
company_name: companyName,
country_code: countryCode // required
})
});
if (!response.ok) return null;
const result = await response.json();
if (result.status === 1) {
return {
companyName,
domain: result.data.domain,
confidence: result.data.confidence_level,
creditsRemaining: result.data.credit_count
};
}
return null;
} catch (error) {
console.error(`Error processing ${companyName}:`, error.message);
return null;
}
}
async bulkLookup(companyNames, countryCode = 'US', delay = 700) {
const results = [];
for (const companyName of companyNames) {
const result = await this.getCompanyDomain(companyName, countryCode);
if (result) results.push(result);
await new Promise(resolve => setTimeout(resolve, delay));
}
return results;
}
async parallelBulkLookup(companyNames, countryCode = 'US', concurrency = 5) {
const results = [];
for (let i = 0; i < companyNames.length; i += concurrency) {
const batch = companyNames.slice(i, i + concurrency);
const settled = await Promise.allSettled(
batch.map(name => this.getCompanyDomain(name, countryCode))
);
settled.forEach(r => {
if (r.status === 'fulfilled' && r.value) results.push(r.value);
});
await new Promise(resolve => setTimeout(resolve, 1000));
}
return results;
}
}
const apiClient = new CompanyNameToDomainAPI('your-api-key-here');
const companyResult = await apiClient.getCompanyDomain('Microsoft', 'US');
if (companyResult) {
console.log(`${companyResult.domain} (${companyResult.confidence}%)`);
}
const bulkResults = await apiClient.bulkLookup(['Apple', 'Google', 'Amazon'], 'US');
bulkResults.forEach(r => console.log(`${r.companyName}: ${r.domain}`));Company name to domain API in Go
Go has an official SDK too: sdk.CUF("cufinder", "US") and you’re done. The net/http version below shows all the moving parts, plus a worker pool for concurrent bulk processing:
package main
import (
"bytes"
"encoding/json"
"fmt"
"io"
"net/http"
"net/url"
"sync"
"time"
)
type APIResponse struct {
Status int `json:"status"`
Data struct {
Domain string `json:"domain"`
ConfidenceLevel int `json:"confidence_level"`
CreditCount int `json:"credit_count"`
} `json:"data"`
}
type Client struct {
APIKey string
BaseURL string
HTTPClient *http.Client
}
func NewClient(apiKey string) *Client {
return &Client{
APIKey: apiKey,
BaseURL: "https://api.cufinder.io/v2/cuf",
HTTPClient: &http.Client{Timeout: 30 * time.Second},
}
}
func (c *Client) GetCompanyDomain(companyName, countryCode string) (*APIResponse, error) {
formData := url.Values{}
formData.Set("company_name", companyName)
formData.Set("country_code", countryCode) // required
req, err := http.NewRequest("POST", c.BaseURL,
bytes.NewBufferString(formData.Encode()))
if err != nil {
return nil, err
}
req.Header.Set("Content-Type", "application/x-www-form-urlencoded")
req.Header.Set("x-api-key", c.APIKey)
resp, err := c.HTTPClient.Do(req)
if err != nil {
return nil, err
}
defer resp.Body.Close()
body, err := io.ReadAll(resp.Body)
if err != nil {
return nil, err
}
var apiResponse APIResponse
if err := json.Unmarshal(body, &apiResponse); err != nil {
return nil, err
}
if apiResponse.Status != 1 {
return nil, fmt.Errorf("no domain found for %s", companyName)
}
return &apiResponse, nil
}
func (c *Client) ConcurrentBulkLookup(companyNames []string,
countryCode string, concurrency int) []*APIResponse {
jobs := make(chan string, len(companyNames))
results := make(chan *APIResponse, len(companyNames))
var wg sync.WaitGroup
for i := 0; i < concurrency; i++ {
wg.Add(1)
go func() {
defer wg.Done()
for name := range jobs {
result, err := c.GetCompanyDomain(name, countryCode)
if err == nil {
results <- result
}
time.Sleep(700 * time.Millisecond) // pacing per worker
}
}()
}
for _, name := range companyNames {
jobs <- name
}
close(jobs)
go func() {
wg.Wait()
close(results)
}()
var final []*APIResponse
for r := range results {
final = append(final, r)
}
return final
}
func main() {
client := NewClient("your-api-key-here")
result, err := client.GetCompanyDomain("Microsoft", "US")
if err != nil {
fmt.Println(err)
} else {
fmt.Printf("%s (%d%%)\n", result.Data.Domain, result.Data.ConfidenceLevel)
}
companies := []string{"Apple", "Google", "Amazon", "Meta"}
for _, r := range client.ConcurrentBulkLookup(companies, "US", 3) {
fmt.Println(r.Data.Domain)
}
}Company name to domain API in Java
No official Java SDK, but the built-in java.net.http client (Java 11+) plus Jackson does everything you need:
import java.net.URI;
import java.net.URLEncoder;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
import java.nio.charset.StandardCharsets;
import java.time.Duration;
import com.fasterxml.jackson.databind.JsonNode;
import com.fasterxml.jackson.databind.ObjectMapper;
public class CompanyNameToDomainAPI {
private final String apiKey;
private final String baseUrl = "https://api.cufinder.io/v2/cuf";
private final HttpClient httpClient;
private final ObjectMapper objectMapper;
public CompanyNameToDomainAPI(String apiKey) {
this.apiKey = apiKey;
this.httpClient = HttpClient.newBuilder()
.connectTimeout(Duration.ofSeconds(30))
.build();
this.objectMapper = new ObjectMapper();
}
public JsonNode getCompanyDomain(String companyName, String countryCode) {
try {
String requestBody =
"company_name=" + URLEncoder.encode(companyName, StandardCharsets.UTF_8) +
"&country_code=" + URLEncoder.encode(countryCode, StandardCharsets.UTF_8);
HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create(baseUrl))
.header("Content-Type", "application/x-www-form-urlencoded")
.header("x-api-key", apiKey)
.POST(HttpRequest.BodyPublishers.ofString(requestBody))
.timeout(Duration.ofSeconds(30))
.build();
HttpResponse<String> response = httpClient.send(
request, HttpResponse.BodyHandlers.ofString());
if (response.statusCode() != 200) {
return null;
}
JsonNode result = objectMapper.readTree(response.body());
if (result.path("status").asInt() == 1) {
return result.path("data");
}
return null;
} catch (Exception e) {
System.err.println("Error processing " + companyName + ": " + e.getMessage());
return null;
}
}
public static void main(String[] args) throws InterruptedException {
CompanyNameToDomainAPI apiClient =
new CompanyNameToDomainAPI("your-api-key-here");
JsonNode data = apiClient.getCompanyDomain("Microsoft", "US");
if (data != null) {
System.out.println(data.path("domain").asText()
+ " (" + data.path("confidence_level").asInt() + "%)");
}
// bulk: pace requests to respect the per-minute limit
for (String name : java.util.List.of("Apple", "Google", "Amazon")) {
JsonNode row = apiClient.getCompanyDomain(name, "US");
if (row != null) {
System.out.println(name + ": " + row.path("domain").asText());
}
Thread.sleep(700);
}
}
}Company name to domain API in Ruby
Ruby has an official SDK as well: client.cuf(company_name: 'cufinder', country_code: 'US'). If you’d rather stay gem-light with HTTParty:
require 'httparty'
require 'json'
class CompanyNameToDomainAPI
include HTTParty
def initialize(api_key)
@api_key = api_key
@base_url = 'https://api.cufinder.io/v2/cuf'
@headers = {
'Content-Type' => 'application/x-www-form-urlencoded',
'x-api-key' => @api_key
}
end
def get_company_domain(company_name, country_code = 'US')
response = self.class.post(
@base_url,
headers: @headers,
body: {
company_name: company_name,
country_code: country_code # required
}
)
return nil unless response.success?
result = JSON.parse(response.body)
return nil unless result['status'] == 1 && result['data']
{
company_name: company_name,
domain: result['data']['domain'],
confidence: result['data']['confidence_level'],
credits_remaining: result['data']['credit_count']
}
rescue StandardError => e
puts "Error processing #{company_name}: #{e.message}"
nil
end
def bulk_lookup(company_names, country_code = 'US', delay = 0.7)
company_names.filter_map do |name|
result = get_company_domain(name, country_code)
sleep(delay) # rate-limit pacing
result
end
end
end
api_client = CompanyNameToDomainAPI.new('your-api-key-here')
if (row = api_client.get_company_domain('Microsoft', 'US'))
puts "#{row[:domain]} (#{row[:confidence]}%)"
end
api_client.bulk_lookup(%w[Apple Google Amazon], 'US').each do |r|
puts "#{r[:company_name]}: #{r[:domain]}"
endBy the way, the official SDKs cover TypeScript, Python, Go, Rust, and Ruby, and the method name is cuf in every one of them. For PHP, Kotlin, and Java, the raw HTTP patterns above ARE the supported route.
What breaks, and what it costs
Happy paths are easy. Here’s what actually goes wrong on real lists:
- Ambiguous names: “Apex” exists in every country and every industry. The required country code narrows it, but when your source column mixes brands and legal names, expect lower confidence scores on those rows. Review them instead of trusting them.
- Acquisitions and rebrands: a company that was acquired last year may resolve to its old domain or its parent’s. No database is instant on corporate changes, so verify before anything high-stakes. For the reverse question (you have the domain and want the current company name), there’s a separate Domain to Company Name endpoint.
- No match: very small or very new companies sometimes return nothing. That’s a data-coverage reality across every vendor, not a bug. Log it and move on.
Cost is simple: 1 credit per record found. No-match lookups generally aren’t charged. But duplicates ARE, so dedupe your list before the run, not after.
💡 Credit math: 1 credit per record found → 4,000 unique names ≈ 4,000 credits worst case. Dedupe first; repeated names and no-matches shouldn't burn budget.
And mind the rate limit: 100 requests per minute per key, on a fixed 60-second window. Go over and you’ll get an HTTP 429 until the window resets. The usage limits page has the details. That’s why every bulk example above sleeps around 0.7 seconds between calls.
🧠 Sanity check: run 20 names before 4,000. Low confidence_level values cluster, usually one country or one messy source column.
Can you do this without an API?
For a handful of names? Absolutely. Type the company name into a search engine, click the official-looking website, done. For five companies, that’s genuinely the right tool, and it’s free.
What about WHOIS? Different question. An ICANN lookup tells you registration details about a domain you ALREADY know. It can’t discover a domain from a company name. People mix these up constantly.
The switch to an API makes sense at scale. My rule from the 2022 cleanup: under ~20 names, search by hand. Over that, the manual error rate (remember our 10% wrong-domain problem) costs more than the credits ever will.
Frequently asked questions
How do I find a company’s domain from its name?
Search it manually for a few names, or use a company name to domain API at scale. The API route returns a verified domain plus a confidence score for every input, which is what makes it safe to automate.
How accurate is a company name to domain API?
CUFinder’s endpoint documents 94-98% accuracy, with a confidence level on each response. Accuracy dips on ambiguous or generic names. That’s exactly why the country code parameter is required, and why you should review low-confidence rows.
Is there a free way to convert company names to domains?
Yes. Manual search is free, and several vendors in this category offer free trials or starter credits. For a small one-off list, manual work is fine. The trade-off shows up at volume, where hand-research time and error rates outgrow the cost of credits.
Can I convert company names to domains in bulk?
Yes. That’s the API’s main job. Batch your list, pace requests under the 100-per-minute limit, and dedupe first so repeated names don’t burn credits. The Python section above is a working bulk pattern you can copy.
What parameters does the CUFinder endpoint require?
Two: company_name and country_code, both required, sent as a form-encoded POST with your key in the x-api-key header. The country code scopes matching to one country, which is how ambiguous names get resolved correctly.
What’s the difference between this and a WHOIS lookup?
WHOIS answers “who registered this domain I already have?” A name to domain API answers “what domain does this company use?” One inspects a known domain; the other discovers an unknown one. They’re complementary, not interchangeable.
Can I get the company name from a domain instead?
Yes. That’s the reverse endpoint, Domain to Company Name, and it’s a separate API. Same auth, same response shape, opposite direction. Useful for cleaning lists where you scraped websites but lost the business names.
What happens when no domain is found?
You get a no-match response, and no-match lookups generally aren’t charged. It happens most with very small or brand-new companies. Log those rows separately and retry them in a quarter. Coverage grows over time.
Go clean that list
Here’s the whole article in one line:
Company name + country code → POST /v2/cuf → domain + confidence score → everything else in your pipeline
Pick your language above, paste the class, and run 20 names before you run 4,000. And if you’re wondering what to build once every record has a domain, the API workflow guides are full of next steps.
Got a list that’s fighting you (weird names, mixed countries, low confidence scores)? Tell me about it. I’ve probably met your list’s evil twin.
⚡ Explore CUFinder APIs
Enrich people and companies at scale. Real-time endpoints for email, phone, revenue, tech stack, LinkedIn data, and more.
Bad
Okay
Good
Amazing
