Sales & Lead Generation

// Lead Generation - works in Node.js 18+ and browsers
const API_KEY = 'YOUR_API_KEY';
const BASE_URL = 'https://app.companydata.com/api/company';

interface LeadFilters {
  countryCode?: string;
  cityName?: string;
  provinceName?: string;
  sicCode?: string;
  employeesMin?: number;
  employeesMax?: number;
  revenueMin?: number;
  revenueMax?: number;
  foundedAfter?: number;
  foundedBefore?: number;
  hasEmail?: boolean;
  hasPhone?: boolean;
  hasWebsite?: boolean;
  hasContactPerson?: boolean;
}

interface Lead {
  id: string;
  companyName: string;
  address: string;
  city: string;
  country: string;
  phone?: string;
  email?: string;
  website?: string;
  contactName?: string;
  contactTitle?: string;
  employees?: number;
  revenue?: number;
  industry?: string;
  sicCode?: string;
  foundingYear?: number;
}

interface LeadSearchResult {
  leads: Lead[];
  totalCount: number;
  page: number;
  pageSize: number;
  totalPages: number;
}

async function fetchApi<T>(endpoint: string, params: Record<string, string | number | boolean>): Promise<T> {
  const url = new URL(`${BASE_URL}/${endpoint}`);
  Object.entries(params).forEach(([key, value]) => {
    if (value !== undefined && value !== '' && value !== null) {
      url.searchParams.append(key, String(value));
    }
  });

  const response = await fetch(url.toString(), {
    headers: { 'x-api-key': API_KEY },
  });

  if (!response.ok) {
    throw new Error(`HTTP ${response.status}: ${await response.text()}`);
  }

  return response.json();
}

function mapToLead(company: Record<string, any>): Lead {
  return {
    id: company['ID'],
    companyName: company['Company Name'],
    address: [company['Address 1'], company['Address 2']].filter(Boolean).join(', '),
    city: company['City'],
    country: company['Country Name'],
    phone: company['Phone Number'],
    email: company['Email'],
    website: company['Website'],
    contactName: company['CEO Name'],
    contactTitle: company['CEO Title'],
    employees: company['Employees Total'] ? parseInt(company['Employees Total']) : undefined,
    revenue: company['Yearly Revenue in U.S. Dollars'] ? parseInt(company['Yearly Revenue in U.S. Dollars']) : undefined,
    industry: company['Business Category'],
    sicCode: company['Business Category Code 1'],
    foundingYear: company['Founding Year'] ? parseInt(company['Founding Year']) : undefined,
  };
}

async function findLeads(
  filters: LeadFilters,
  page = 1,
  pageSize = 25
): Promise<LeadSearchResult> {
  const params: Record<string, string | number | boolean> = {
    page,
    pageSize,
  };

  // Location filters
  if (filters.countryCode) params.countryCode = filters.countryCode;
  if (filters.cityName) params.cityName = filters.cityName;
  if (filters.provinceName) params.provinceName = filters.provinceName;

  // Industry filter
  if (filters.sicCode) params.sic4Digits = filters.sicCode;

  // Size filters
  if (filters.employeesMin) params['employeesTotal[min]'] = filters.employeesMin;
  if (filters.employeesMax) params['employeesTotal[max]'] = filters.employeesMax;

  // Revenue filters
  if (filters.revenueMin) params['annualSales[min]'] = filters.revenueMin;
  if (filters.revenueMax) params['annualSales[max]'] = filters.revenueMax;

  // Age filters
  if (filters.foundedAfter) params['foundingYears[min]'] = filters.foundedAfter;
  if (filters.foundedBefore) params['foundingYears[max]'] = filters.foundedBefore;

  // Contact info filters
  if (filters.hasEmail) params.hasEmail = 'true';
  if (filters.hasPhone) params.hasPhone = 'true';
  if (filters.hasWebsite) params.hasWebsite = 'true';
  if (filters.hasContactPerson) params.hasContactPerson = 'true';

  const response = await fetchApi<{
    data: {
      records: Record<string, any>[];
      totalCount?: number;
    };
    page: number;
    pageSize: number;
  }>('export', params);

  return {
    leads: (response.data?.records || []).map(mapToLead),
    totalCount: response.data?.totalCount || 0,
    page: response.page,
    pageSize: response.pageSize,
    totalPages: Math.ceil((response.data?.totalCount || 0) / pageSize),
  };
}

// Export all leads matching filters (paginated)
async function* exportAllLeads(
  filters: LeadFilters,
  pageSize = 100
): AsyncGenerator<Lead[], void, unknown> {
  let page = 1;
  let hasMore = true;

  while (hasMore) {
    const result = await findLeads(filters, page, pageSize);

    if (result.leads.length > 0) {
      yield result.leads;
    }

    hasMore = page < result.totalPages;
    page++;

    // Rate limiting
    if (hasMore) {
      await new Promise(resolve => setTimeout(resolve, 100));
    }
  }
}

// Example usage
async function main() {
  // Find software companies in Netherlands with 10-100 employees
  const filters: LeadFilters = {
    countryCode: 'NL',
    sicCode: '7371', // Computer Programming Services
    employeesMin: 10,
    employeesMax: 100,
    hasEmail: true,
    hasPhone: true,
  };

  console.log('Searching for leads...');
  const result = await findLeads(filters, 1, 10);

  console.log(`Found ${result.totalCount} matching companies\n`);

  result.leads.forEach((lead, i) => {
    console.log(`${i + 1}. ${lead.companyName}`);
    console.log(`   ${lead.city}, ${lead.country}`);
    console.log(`   Employees: ${lead.employees || 'N/A'}`);
    console.log(`   Phone: ${lead.phone || 'N/A'}`);
    console.log(`   Email: ${lead.email || 'N/A'}`);
    console.log('');
  });
}

main();