Company URL Research API: Free Options and Working Code

[
  {
    "name": "Salesforce",
    "domain": "salesforce.com",
    "logo": null
  },
  {
    "name": "Salesforce Ben",
    "domain": "salesforceben.com",
    "logo": null
  }
]

// Company name to domain lookup with match scoring.
// Free, no API key. Works in the browser and in Node 18 or later.

const ENDPOINT = 'https://autocomplete.clearbit.com/v1/companies/suggest?query=';

// Legal suffixes hurt matching. "HubSpot Inc." finds far worse than "HubSpot".
const SUFFIXES = /\b(inc|incorporated|corp|corporation|co|company|ltd|limited|llc|llp|plc|gmbh|ag|sa|srl|spa|bv|nv|ab|oy|pty|pvt|private|group|holdings|international|technologies|solutions|services)\b\.?/gi;

function normalise(s) {
  return String(s || '').toLowerCase()
    .replace(/[^a-z0-9 ]+/g, ' ')
    .replace(/\s+/g, ' ')
    .trim();
}

function stripSuffix(name) {
  const out = String(name).replace(SUFFIXES, ' ').replace(/\s+/g, ' ').trim();
  return out.length >= 2 ? out : String(name).trim();
}

// Dice coefficient over character bigrams. Returns 0 to 1.
function similarity(a, b) {
  a = normalise(a); b = normalise(b);
  if (!a || !b) return 0;
  if (a === b) return 1;
  if (a.length < 2 || b.length < 2) return 0;

  const pairs = new Map();
  for (let i = 0; i < a.length - 1; i++) {
    const bg = a.slice(i, i + 2);
    pairs.set(bg, (pairs.get(bg) || 0) + 1);
  }
  let hits = 0;
  for (let i = 0; i < b.length - 1; i++) {
    const bg = b.slice(i, i + 2);
    if (pairs.get(bg) > 0) { pairs.set(bg, pairs.get(bg) - 1); hits++; }
  }
  const dice = (2 * hits) / (a.length - 1 + b.length - 1);

  // "Zoom" vs "Zoom Video Communications" scores near zero on raw bigrams
  // but is probably right. Lift whole-word prefixes into the middle band.
  // Deliberately below the High cutoff: "Salesforce" is also a prefix of
  // "Salesforce Ben", which is a different website entirely.
  const [short, long] = a.length <= b.length ? [a, b] : [b, a];
  if (long.startsWith(short + ' ')) {
    return Math.max(dice, short.length >= 6 ? 0.78 : 0.60);
  }
  return dice;
}

function bandFor(score) {
  if (score >= 0.85) return 'High';
  if (score >= 0.50) return 'Medium';
  return 'Low';
}

async function findCompanyURL(companyName) {
  const query = stripSuffix(companyName);

  let res;
  try {
    res = await fetch(ENDPOINT + encodeURIComponent(query));
  } catch (err) {
    // Network failure is NOT the same as "company not found".
    // Conflating them is the most common bug in these scripts.
    return { input: companyName, status: 'request_failed', error: String(err) };
  }
  if (!res.ok) {
    return { input: companyName, status: 'request_failed', error: 'HTTP ' + res.status };
  }

  const data = await res.json();
  if (!Array.isArray(data) || data.length === 0) {
    return { input: companyName, status: 'not_found' };
  }

  const ranked = data
    .map(c => ({
      name: c.name,
      domain: c.domain,
      score: Math.max(similarity(query, c.name), similarity(companyName, c.name))
    }))
    .sort((a, b) => b.score - a.score);

  const best = ranked[0];
  return {
    input:        companyName,
    status:       'ok',
    matchedName:  best.name,
    domain:       best.domain,
    url:          'https://' + best.domain,
    score:        Number(best.score.toFixed(2)),
    band:         bandFor(best.score),
    alternatives: ranked.slice(1, 4)   // check these when band is not High
  };
}

// Bulk, with a small delay so you are polite to a free endpoint.
const sleep = ms => new Promise(r => setTimeout(r, ms));

async function bulkLookup(names, delayMs = 250) {
  const out = [];
  for (const name of names) {
    out.push(await findCompanyURL(name));
    await sleep(delayMs);
  }
  return out;
}

// Example
bulkLookup(['Salesforce', 'HubSpot Inc.', 'Bolt', 'Notion', 'Figma'])
  .then(rows => {
    console.table(rows.map(r => ({
      input: r.input, domain: r.domain || '', band: r.band || r.status
    })));
    const review = rows.filter(r => r.band === 'Medium' || r.band === 'Low');
    console.log('Rows needing a human check:', review.length);
  });

"""Company name to domain lookup with match scoring.
Free Clearbit Autocomplete endpoint. No API key needed.
"""

import csv
import re
import time
import requests

ENDPOINT = "https://autocomplete.clearbit.com/v1/companies/suggest"

SUFFIXES = re.compile(
    r"\b(inc|incorporated|corp|corporation|co|company|ltd|limited|llc|llp|plc|"
    r"gmbh|ag|sa|srl|spa|bv|nv|ab|oy|pty|pvt|private|group|holdings|"
    r"international|technologies|solutions|services)\b\.?",
    re.IGNORECASE,
)


def normalise(s: str) -> str:
    s = re.sub(r"[^a-z0-9 ]+", " ", str(s or "").lower())
    return re.sub(r"\s+", " ", s).strip()


def strip_suffix(name: str) -> str:
    out = re.sub(r"\s+", " ", SUFFIXES.sub(" ", str(name))).strip()
    return out if len(out) >= 2 else str(name).strip()


def similarity(a: str, b: str) -> float:
    """Dice coefficient over character bigrams, 0 to 1."""
    a, b = normalise(a), normalise(b)
    if not a or not b:
        return 0.0
    if a == b:
        return 1.0
    if len(a) < 2 or len(b) < 2:
        return 0.0

    pairs = {}
    for i in range(len(a) - 1):
        bg = a[i:i + 2]
        pairs[bg] = pairs.get(bg, 0) + 1

    hits = 0
    for i in range(len(b) - 1):
        bg = b[i:i + 2]
        if pairs.get(bg, 0) > 0:
            pairs[bg] -= 1
            hits += 1

    dice = (2 * hits) / (len(a) - 1 + len(b) - 1)

    short, long = (a, b) if len(a) <= len(b) else (b, a)
    if long.startswith(short + " "):
        return max(dice, 0.78 if len(short) >= 6 else 0.60)
    return dice


def band_for(score: float) -> str:
    if score >= 0.85:
        return "High"
    if score >= 0.50:
        return "Medium"
    return "Low"


def find_company_url(company_name: str) -> dict:
    query = strip_suffix(company_name)
    try:
        resp = requests.get(ENDPOINT, params={"query": query}, timeout=10)
        resp.raise_for_status()
        data = resp.json()
    except Exception as exc:
        # A failed request is not the same as "no such company".
        return {"input": company_name, "status": "request_failed", "error": str(exc)}

    if not data:
        return {"input": company_name, "status": "not_found"}

    ranked = sorted(
        (
            {
                "name": c.get("name", ""),
                "domain": c.get("domain", ""),
                "score": max(
                    similarity(query, c.get("name", "")),
                    similarity(company_name, c.get("name", "")),
                ),
            }
            for c in data
        ),
        key=lambda r: r["score"],
        reverse=True,
    )

    best = ranked[0]
    return {
        "input": company_name,
        "status": "ok",
        "matched_name": best["name"],
        "domain": best["domain"],
        "url": "https://" + best["domain"],
        "score": round(best["score"], 2),
        "band": band_for(best["score"]),
        "alternatives": "; ".join(f"{r['name']} ({r['domain']})" for r in ranked[1:4]),
    }


def bulk_lookup(names, delay=0.25):
    results = []
    total = len(names)
    for i, name in enumerate(names, 1):
        print(f"[{i}/{total}] {name}")
        results.append(find_company_url(name))
        time.sleep(delay)
    return results


def save_csv(rows, filename="company_urls.csv"):
    cols = ["input", "status", "matched_name", "domain", "url",
            "score", "band", "alternatives"]
    with open(filename, "w", newline="", encoding="utf-8-sig") as fh:
        writer = csv.DictWriter(fh, fieldnames=cols, extrasaction="ignore")
        writer.writeheader()
        writer.writerows(rows)
    print(f"Wrote {len(rows)} rows to {filename}")


if __name__ == "__main__":
    companies = ["Salesforce", "HubSpot Inc.", "Stripe", "Shopify", "Bolt", "Notion"]
    rows = bulk_lookup(companies)
    save_csv(rows)

    ok = sum(1 for r in rows if r["status"] == "ok")
    high = sum(1 for r in rows if r.get("band") == "High")
    failed = sum(1 for r in rows if r["status"] == "request_failed")
    print(f"Resolved {ok}/{len(rows)}. High confidence: {high}. Request errors: {failed}.")

/**
 * Look up a company's official website domain.
 * Free Clearbit Autocomplete endpoint, no API key.
 *
 * @param {string} companyName Company name to look up.
 * @param {number} refresh     Optional. Pass a changing cell to force a re-run.
 * @return {string} The URL, or a readable status.
 * @customfunction
 */
function GETCOMPANYURL(companyName, refresh) {
  if (!companyName || String(companyName).trim() === '') return '';

  var name = String(companyName).trim()
    .replace(/\b(Inc|Corp|Corporation|Co|Ltd|Limited|LLC|PLC|GmbH|Pvt|Private)\b\.?/gi, '')
    .replace(/\s+/g, ' ')
    .trim();

  var url = 'https://autocomplete.clearbit.com/v1/companies/suggest?query='
          + encodeURIComponent(name);

  try {
    var res = UrlFetchApp.fetch(url, { muteHttpExceptions: true });
    if (res.getResponseCode() !== 200) return 'Lookup unavailable';

    var data = JSON.parse(res.getContentText());
    if (!data || data.length === 0) return 'Not found';

    return 'https://' + data[0].domain;
  } catch (e) {
    return 'Lookup unavailable';
  }
}

/**
 * Returns the name the database actually matched, so you can eyeball
 * whether the domain belongs to the company you meant.
 * @customfunction
 */
function GETMATCHEDNAME(companyName, refresh) {
  if (!companyName || String(companyName).trim() === '') return '';
  var url = 'https://autocomplete.clearbit.com/v1/companies/suggest?query='
          + encodeURIComponent(String(companyName).trim());
  try {
    var res = UrlFetchApp.fetch(url, { muteHttpExceptions: true });
    if (res.getResponseCode() !== 200) return 'Lookup unavailable';
    var data = JSON.parse(res.getContentText());
    return (data && data.length) ? data[0].name : 'Not found';
  } catch (e) {
    return 'Lookup unavailable';
  }
}

import os
import requests

API_KEY = os.environ["HUNTER_API_KEY"]   # never hard-code a key in your source

def enrich_company(name_or_domain: str, by_domain: bool = False) -> dict:
    params = {"api_key": API_KEY}
    params["domain" if by_domain else "company"] = name_or_domain

    resp = requests.get("https://api.hunter.io/v2/companies/find",
                        params=params, timeout=15)

    if resp.status_code == 401:
        raise RuntimeError("Bad API key")
    if resp.status_code == 429:
        raise RuntimeError("Rate limited or out of credits")
    resp.raise_for_status()

    return resp.json().get("data") or {}

info = enrich_company("Shopify")
print(info.get("domain"), info.get("industry"), info.get("country"))

"""Measure lookup accuracy on YOUR list.

1. Build a CSV called truth.csv with two columns: name,correct_domain
2. Fill in 30 to 50 rows from your real data, verified by hand.
3. Run this. Requires find_company_url() from the section above.
"""

import csv
from collections import Counter


def load_truth(path="truth.csv"):
    with open(path, newline="", encoding="utf-8-sig") as fh:
        return list(csv.DictReader(fh))


def clean_domain(d):
    return (d or "").lower().replace("www.", "").strip().rstrip("/")


def benchmark(path="truth.csv"):
    rows = load_truth(path)
    bands = Counter()
    correct_by_band = Counter()
    misses = []

    for row in rows:
        expected = clean_domain(row["correct_domain"])
        result = find_company_url(row["name"])

        if result["status"] != "ok":
            bands[result["status"]] += 1
            misses.append((row["name"], expected, result["status"]))
            continue

        band = result["band"]
        bands[band] += 1
        got = clean_domain(result["domain"])

        if got == expected:
            correct_by_band[band] += 1
        else:
            misses.append((row["name"], expected, got + " [" + band + "]"))

    total = len(rows)
    right = sum(correct_by_band.values())
    print(f"Overall: {right}/{total} = {right / total:.0%}\n")

    for band in ("High", "Medium", "Low"):
        n = bands[band]
        if n:
            print(f"{band:7} {correct_by_band[band]:3}/{n:3} "
                  f"= {correct_by_band[band] / n:.0%}")

    if bands["not_found"]:
        print(f"\nNot in database: {bands['not_found']}")
    if bands["request_failed"]:
        print(f"Request errors:  {bands['request_failed']} (re-run these)")

    print("\nMisses:")
    for name, expected, got in misses[:25]:
        print(f"  {name:30} expected {expected:28} got {got}")


if __name__ == "__main__":
    benchmark()