Bulks Company Enrichment provides comprehensive business intelligence for thousands of companies simultaneously. Gather detailed company information, contact data, and organizational insights to enhance your prospect research and targeting efforts.
Key Features
Company Intelligence: Gather detailed information about target companies
Contact Discovery: Find key personnel and their contact information
Data Enrichment: Enhance existing company records with additional details
Bulk Processing: Process up to 15,000 companies in one operation
Comprehensive Profiles: Access company size, industry, location, and more
Integration Ready: Export enriched data for CRM integration
How Company Enrichment Bulk Works
Provide Company List: Input company domains or names
Select Data Fields: Choose what information to enrich (contacts, company details, etc.)
Process Enrichment: Launch the bulk enrichment operation
Review Enhanced Data: Examine the enriched company profiles
Export Results: Download comprehensive company intelligence
Limitations
Each Bulk is limited to 15,000 domains
Additional rows will be skipped
Some special or unexpected characters may be deleted in the file
Invalid websites won't be imported
Duplicate URLs won't be imported
For better results, we use the domain name instead of the company name
Go SDK Integration
Installation
Code
go get github.com/tomba-io/go
Basic Company Enrichment
Code
package mainimport ( "fmt" "log" "strings" "time" "github.com/tomba-io/go/tomba" "github.com/tomba-io/go/tomba/models")func main() { // Initialize Tomba client client := tomba.NewClient("YOUR_TOMBA_KEY", "YOUR_TOMBA_SECRET") // Create Company Enrichment Bulk params := &models.BulkCreateParams{ Name: "Enterprise Prospects Q1 2024", List: "stripe.com\nshopify.com\nzoom.us\nslack.com\ndropbox.com\nnotion.so", Sources: true, // Include data sources Verify: true, // Verify found emails } // Create the bulk operation response, err := client.CreateBulk(models.BulkTypeCompany, params) if err != nil { log.Fatal("Error creating company enrichment bulk:", err) } bulkID := *response.Data.ID fmt.Printf("Company Enrichment Bulk created with ID: %d\n", bulkID) // Launch the bulk operation launchResp, err := client.LaunchBulk(models.BulkTypeCompany, bulkID) if err != nil { log.Fatal("Error launching bulk:", err) } fmt.Printf("Bulk launched: %s\n", launchResp.Data.Message) // Monitor progress fmt.Println("Monitoring enrichment progress...") for { progress, err := client.GetBulkProgress(models.BulkTypeCompany, bulkID) if err != nil { log.Printf("Error getting progress: %v", err) break } fmt.Printf("Progress: %d%% (%d companies processed)\n", progress.Progress, progress.Processed) if progress.Progress >= 100 { fmt.Println("Company enrichment completed!") break } time.Sleep(10 * time.Second) } // Download enriched results err = client.SaveBulkResults(models.BulkTypeCompany, bulkID, "./enriched_companies.csv", "full") if err != nil { log.Printf("Error downloading results: %v", err) } else { fmt.Println("Enriched company data saved to ./enriched_companies.csv") }}
Advanced Company Enrichment with File Upload
Code
func enrichFromCSV(client *tomba.Tomba, filePath string) error { // For large lists, you might want to use CSV upload params := &models.BulkCreateParams{ Name: "CSV Company Enrichment", Sources: true, Verify: true, Delimiter: ",", Column: 1, // Domain column in CSV } // Create with file upload response, err := client.CreateBulkWithFile(models.BulkTypeCompany, params, filePath) if err != nil { return fmt.Errorf("failed to create bulk with file: %w", err) } bulkID := *response.Data.ID fmt.Printf("Company enrichment bulk created from CSV with ID: %d\n", bulkID) // Launch and monitor _, err = client.LaunchBulk(models.BulkTypeCompany, bulkID) if err != nil { return fmt.Errorf("failed to launch bulk: %w", err) } return monitorAndDownload(client, models.BulkTypeCompany, bulkID, "./csv_enriched_results.csv")}func monitorAndDownload(client *tomba.Tomba, bulkType models.BulkType, bulkID int64, outputPath string) error { // Monitor with timeout timeout := time.After(45 * time.Minute) ticker := time.NewTicker(30 * time.Second) defer ticker.Stop() for { select { case <-timeout: return fmt.Errorf("enrichment operation timed out after 45 minutes") case <-ticker.C: progress, err := client.GetBulkProgress(bulkType, bulkID) if err != nil { log.Printf("Error checking progress: %v", err) continue } fmt.Printf("Enrichment Progress: %d%% (%d processed)\n", progress.Progress, progress.Processed) if progress.Progress >= 100 { // Download results err = client.SaveBulkResults(bulkType, bulkID, outputPath, "full") if err != nil { return fmt.Errorf("failed to download results: %w", err) } fmt.Printf("Results downloaded to: %s\n", outputPath) return nil } } }}
Batch Processing for Large Lists
Code
func batchEnrichCompanies(client *tomba.Tomba, domains []string, batchSize int) error { if len(domains) == 0 { return fmt.Errorf("no domains provided") } // Split into batches to stay within limits for i := 0; i < len(domains); i += batchSize { end := i + batchSize if end > len(domains) { end = len(domains) } if end-i > 15000 { end = i + 15000 // Respect API limit } batch := domains[i:end] batchNum := (i / batchSize) + 1 fmt.Printf("Processing batch %d (%d domains)...\n", batchNum, len(batch)) params := &models.BulkCreateParams{ Name: fmt.Sprintf("Company Batch %d - %s", batchNum, time.Now().Format("2006-01-02")), List: strings.Join(batch, "\n"), Sources: true, Verify: true, } response, err := client.CreateBulk(models.BulkTypeCompany, params) if err != nil { log.Printf("Error creating batch %d: %v", batchNum, err) continue } bulkID := *response.Data.ID // Launch batch _, err = client.LaunchBulk(models.BulkTypeCompany, bulkID) if err != nil { log.Printf("Error launching batch %d: %v", batchNum, err) continue } fmt.Printf("Batch %d launched with ID: %d\n", batchNum, bulkID) // Small delay between batches time.Sleep(5 * time.Second) } return nil}
Company Enrichment Management
Code
func manageCompanyBulks(client *tomba.Tomba) { // Get all company enrichment bulks allBulks, err := client.GetAllCompanyBulks(&models.BulkGetParams{ Page: 1, Limit: 20, Direction: "desc", Filter: "all", }) if err != nil { log.Printf("Error getting company bulks: %v", err) return } fmt.Printf("Total company enrichment bulks: %d\n", allBulks.Meta.Total) // Process each bulk for _, bulk := range allBulks.Data { fmt.Printf("Bulk: %s (ID: %d)\n", bulk.Name, bulk.BulkID) fmt.Printf(" Progress: %d%%, Status: %t, Expired: %t\n", bulk.Progress, bulk.Status, bulk.Expired) if bulk.TotalEmails != nil { fmt.Printf(" Total Emails Found: %d\n", *bulk.TotalEmails) } // Download completed and unused bulks if bulk.Progress >= 100 && !bulk.Used && !bulk.Expired { filename := fmt.Sprintf("./company_enrichment_%d.csv", bulk.BulkID) err := client.SaveBulkResults( models.BulkTypeCompany, bulk.BulkID, filename, "full", ) if err == nil { fmt.Printf(" ✓ Downloaded results to %s\n", filename) } else { fmt.Printf(" ✗ Failed to download: %v\n", err) } } } // Clean up old bulks cleanupOldBulks(client, allBulks.Data)}func cleanupOldBulks(client *tomba.Tomba, bulks []models.BulkItem) { cutoffDate := time.Now().AddDate(0, -3, 0) // 3 months ago for _, bulk := range bulks { // Archive bulks older than 3 months if bulk.CreatedAt.Before(cutoffDate) && bulk.Progress >= 100 { _, err := client.ArchiveBulk(models.BulkTypeCompany, bulk.BulkID) if err == nil { fmt.Printf("Archived old bulk: %s (ID: %d)\n", bulk.Name, bulk.BulkID) } } }}