Company URL Research API — Free Options, Code Examples & Complete Guide

[
  {
    "name": "Salesforce",
    "domain": "salesforce.com",
    "logo": "https://logo.clearbit.com/salesforce.com"
  }
]

// Company URL lookup using Clearbit Autocomplete API
// Free - no API key needed - works in browser and Node.js

async function findCompanyURL(companyName) {
  // Build the request URL with the company name
  const url = `https://autocomplete.clearbit.com/v1/companies/suggest?query=${encodeURIComponent(companyName)}`;

  try {
    const response = await fetch(url);
    const data = await response.json();

    // If no results found, return null
    if (!data || data.length === 0) {
      return { company: companyName, url: null, confidence: 'Not found' };
    }

    // The first result is the most likely match
    const topResult = data[0];

    return {
      company:    companyName,
      foundName:  topResult.name,
      url:        `https://${topResult.domain}`,
      domain:     topResult.domain,
      confidence: 'High'   // Higher for exact matches
    };

  } catch (error) {
    console.error('Lookup failed:', error);
    return { company: companyName, url: null, confidence: 'Error' };
  }
}

// Usage — single company
findCompanyURL('Stripe').then(result => {
  console.log(result);
  // Output: { company: 'Stripe', url: 'https://stripe.com', domain: 'stripe.com', ... }
});

// Bulk company URL lookup — processes a list with a polite delay
// Add 300ms between requests to avoid rate limiting

const sleep = (ms) => new Promise(r => setTimeout(r, ms));

async function bulkFindCompanyURLs(companyNames) {
  const results = [];

  for (const name of companyNames) {
    const result = await findCompanyURL(name);
    results.push(result);
    await sleep(300); // Wait 300ms between each request
  }

  return results;
}

// Usage
const companies = ['Salesforce', 'HubSpot', 'Stripe', 'Notion', 'Figma'];

bulkFindCompanyURLs(companies).then(results => {
  // Print results as a table
  console.table(results);

  // Filter to only found results
  const found = results.filter(r => r.url);
  console.log(`Found ${found.length} out of ${companies.length} companies`);
});

import requests
import time
import csv

def find_company_url(company_name: str) -> dict:
    """
    Look up a company's official website URL.
    Uses the free Clearbit Autocomplete API — no key needed.
    Returns a dict with: company, url, domain, found_name
    """
    endpoint = "https://autocomplete.clearbit.com/v1/companies/suggest"
    params = {"query": company_name}

    try:
        resp = requests.get(endpoint, params=params, timeout=10)
        resp.raise_for_status()
        data = resp.json()

        if not data:
            return {"company": company_name, "url": None, "confidence": "not_found"}

        top = data[0]   # First result is most relevant
        return {
            "company":    company_name,
            "found_name": top["name"],
            "url":        f"https://{top['domain']}",
            "domain":     top["domain"],
            "confidence": "high"
        }

    except Exception as e:
        print(f"Error looking up {company_name}: {e}")
        return {"company": company_name, "url": None, "confidence": "error"}


def bulk_lookup(company_list: list, delay=0.3) -> list:
    """Process a list of company names. delay = seconds between requests."""
    results = []
    for i, name in enumerate(company_list, 1):
        print(f"Looking up {i}/{len(company_list)}: {name}")
        result = find_company_url(name)
        results.append(result)
        time.sleep(delay)   # Polite delay between requests
    return results


def save_to_csv(results: list, filename="company_urls.csv"):
    """Save results to a CSV file."""
    with open(filename, "w", newline="", encoding="utf-8") as f:
        writer = csv.DictWriter(f, fieldnames=["company","found_name","url","domain","confidence"])
        writer.writeheader()
        writer.writerows(results)
    print(f"Saved {len(results)} results to {filename}")


# ── Main: run on a list of companies ──────────────────
if __name__ == "__main__":
    companies = [
        "Salesforce",
        "HubSpot",
        "Stripe",
        "Shopify",
        "Airbnb",
        "Notion",
    ]

    results = bulk_lookup(companies)
    save_to_csv(results)

    # Print summary
    found = sum(1 for r in results if r["url"])
    print(f"\nFound URLs for {found} of {len(companies)} companies.")

/**
 * Get the official website URL for a company name.
 * Uses the free Clearbit Autocomplete API.
 *
 * @param {string} companyName The name of the company to look up
 * @return {string} The official website URL, or "Not found" if unavailable
 * @customfunction
 */
function GETCOMPANYURL(companyName) {
  if (!companyName || companyName.toString().trim() === "") {
    return "";
  }

  try {
    var encoded = encodeURIComponent(companyName.toString().trim());
    var url = "https://autocomplete.clearbit.com/v1/companies/suggest?query=" + encoded;
    var response = UrlFetchApp.fetch(url);
    var data = JSON.parse(response.getContentText());

    if (data && data.length > 0) {
      return "https://" + data[0].domain;  // Return the full URL
    } else {
      return "Not found";
    }
  } catch (e) {
    return "Error: " + e.message;
  }
}

https://api.targetcompanyurlresearch.com/v1

Authorization: Bearer YOUR_API_KEY

// TargetCompanyURLResearch.com API — Bulk Lookup
// Requires: Agency plan API key

const API_KEY  = 'your_api_key_here';  // Get from your account dashboard
const BASE_URL = 'https://api.targetcompanyurlresearch.com/v1';

async function bulkLookup(companies, options = {}) {
  const response = await fetch(`${BASE_URL}/lookup/bulk`, {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
      'Authorization': `Bearer ${API_KEY}`
    },
    body: JSON.stringify({
      companies:        companies,
      include_careers:  options.careers  || false,
      country:          options.country  || null
    })
  });

  if (!response.ok) {
    throw new Error(`API error: ${response.status} ${response.statusText}`);
  }

  return response.json();
}

// Usage example
const myCompanies = ['Salesforce', 'HubSpot', 'Stripe', 'Shopify', 'Airbnb'];

bulkLookup(myCompanies, { careers: true, country: 'GB' })
  .then(data => {
    console.log(`Found ${data.results.length} results:`);
    data.results.forEach(r => {
      console.log(`${r.company} → ${r.url} [${r.confidence}]`);
      if (r.careers_url) {
        console.log(`  Careers: ${r.careers_url}`);
      }
    });
  })
  .catch(console.error);