Author Finder Bulk

Overview

Bulk Author Finder helps you discover contact information for content creators, blog authors, and website contributors. Perfect for blogger outreach, content partnerships, and influencer marketing campaigns.

Key Features

• Content Author Discovery: Find contact details for website authors and contributors
• Blogger Outreach: Build lists for content marketing and partnership campaigns
• Influencer Identification: Discover key voices in your industry
• Bulk Processing: Process up to 5,000 URLs in a single operation
• Contact Enrichment: Gather comprehensive author profiles and contact methods

How Author Finder Bulk Works

1. Identify Target Websites: Compile URLs of websites, blogs, or content platforms
2. Upload URL List: Provide website URLs for author discovery
3. Process Content: Analyze websites to identify authors and contributors
4. Extract Contacts: Discover contact information for identified authors
5. Export Results: Download author contact lists for outreach campaigns

Limitations

• Each Bulk is limited to 5,000 URLs
• 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

Go SDK Integration

Installation

Code
 
go get github.com/tomba-io/go

Basic Usage

Code
 
package main

import (
    "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 Author Finder Bulk
    params := &models.BulkCreateParams{
        Name:    "Tech Blog Authors Q1 2024",
        List:    "https://blog.stripe.com\nhttps://blog.shopify.com\nhttps://blog.zoom.us\nhttps://slack.com/blog",
        Sources: true, // Include source information
        Verify:  true, // Verify found emails
    }

    // Create the bulk operation
    response, err := client.CreateBulk(models.BulkTypeAuthor, params)
    if err != nil {
        log.Fatal("Error creating bulk:", err)
    }

    bulkID := *response.Data.ID
    fmt.Printf("Author Finder Bulk created with ID: %d\n", bulkID)

    // Launch the bulk operation
    launchResp, err := client.LaunchBulk(models.BulkTypeAuthor, bulkID)
    if err != nil {
        log.Fatal("Error launching bulk:", err)
    }

    fmt.Printf("Bulk launched: %s\n", launchResp.Data.Message)

    // Monitor progress
    for {
        progress, err := client.GetBulkProgress(models.BulkTypeAuthor, bulkID)
        if err != nil {
            log.Printf("Error getting progress: %v", err)
            break
        }

        fmt.Printf("Progress: %d%% (%d processed)\n",
            progress.Progress, progress.Processed)

        if progress.Progress >= 100 {
            fmt.Println("Author search completed!")
            break
        }

        time.Sleep(5 * time.Second)
    }

    // Download results
    err = client.SaveBulkResults(models.BulkTypeAuthor, bulkID, "./authors.csv", "full")
    if err != nil {
        log.Printf("Error downloading results: %v", err)
    } else {
        fmt.Println("Results saved to ./authors.csv")
    }
}

Advanced Management

Code
 
func manageAuthorBulks(client *tomba.Tomba) {
    // Get all author finder bulks with pagination
    allBulks, err := client.GetAllAuthorBulks(&models.BulkGetParams{
        Page:      1,
        Limit:     10,
        Direction: "desc",
        Filter:    "all",
    })
    if err != nil {
        log.Printf("Error getting bulks: %v", err)
        return
    }

    fmt.Printf("Total author bulks: %d\n", allBulks.Meta.Total)

    // Process each bulk
    for _, bulk := range allBulks.Data {
        fmt.Printf("Bulk: %s (ID: %d) - Progress: %d%%\n",
            bulk.Name, bulk.BulkID, bulk.Progress)

        // Download completed bulks
        if bulk.Progress >= 100 && !bulk.Used {
            err := client.SaveBulkResults(
                models.BulkTypeAuthor,
                bulk.BulkID,
                fmt.Sprintf("./author_results_%d.csv", bulk.BulkID),
                "full",
            )
            if err == nil {
                fmt.Printf("Downloaded results for bulk %d\n", bulk.BulkID)
            }
        }
    }

    // Rename a bulk
    bulkID := int64(12345) // Replace with actual ID
    renameParams := &models.BulkRenameParams{
        Name: "Updated Author Campaign 2024",
    }

    _, err = client.RenameBulk(models.BulkTypeAuthor, bulkID, renameParams)
    if err == nil {
        fmt.Println("Bulk renamed successfully")
    }

    // Archive old bulks
    _, err = client.ArchiveBulk(models.BulkTypeAuthor, bulkID)
    if err == nil {
        fmt.Println("Bulk archived successfully")
    }
}

Error Handling and Best Practices

Code
 
func robustAuthorSearch(client *tomba.Tomba, urls []string) error {
    // Validate input
    if len(urls) == 0 {
        return fmt.Errorf("no URLs provided")
    }

    if len(urls) > 5000 {
        return fmt.Errorf("too many URLs: %d (max: 5000)", len(urls))
    }

    // Create URL list
    urlList := strings.Join(urls, "\n")

    params := &models.BulkCreateParams{
        Name:    fmt.Sprintf("Author Search %s", time.Now().Format("2006-01-02")),
        List:    urlList,
        Sources: true,
        Verify:  true,
    }

    // Create with retry logic
    var response *models.BulkCreateResponse
    var err error

    for i := 0; i < 3; i++ {
        response, err = client.CreateBulk(models.BulkTypeAuthor, params)
        if err == nil {
            break
        }

        log.Printf("Attempt %d failed: %v", i+1, err)
        time.Sleep(time.Duration(i+1) * time.Second)
    }

    if err != nil {
        return fmt.Errorf("failed to create bulk after retries: %w", err)
    }

    // Launch and monitor
    bulkID := *response.Data.ID

    _, err = client.LaunchBulk(models.BulkTypeAuthor, bulkID)
    if err != nil {
        return fmt.Errorf("failed to launch bulk: %w", err)
    }

    // Wait for completion with timeout
    timeout := time.After(30 * time.Minute)
    ticker := time.NewTicker(30 * time.Second)
    defer ticker.Stop()

    for {
        select {
        case <-timeout:
            return fmt.Errorf("bulk operation timed out")

        case <-ticker.C:
            progress, err := client.GetBulkProgress(models.BulkTypeAuthor, bulkID)
            if err != nil {
                log.Printf("Error checking progress: %v", err)
                continue
            }

            fmt.Printf("Progress: %d%%\n", progress.Progress)

            if progress.Progress >= 100 {
                fmt.Println("Author search completed successfully!")
                return nil
            }
        }
    }
}

Input Format Examples

Text List (most common):

Code
 
https://blog.stripe.com
https://blog.shopify.com
https://blog.zoom.us
https://slack.com/blog
https://blog.dropbox.com

CSV File Upload:

Code
 
URL
https://blog.stripe.com
https://blog.shopify.com
https://blog.zoom.us
https://slack.com/blog

Best Practices

• Quality URLs: Use complete, accessible blog and website URLs
• Verify Results: Enable email verification for higher quality contacts
• Descriptive Names: Use clear, descriptive names for easy identification
• Monitor Progress: Check progress regularly for large operations
• Clean Results: Review and clean results before outreach campaigns
• Respect Limits: Stay within the 5,000 URL limit per bulk
• Regular Maintenance: Archive completed bulks to keep dashboard organized

Common Use Cases

• Blogger Outreach: Find authors for guest posting opportunities
• Influencer Marketing: Identify key content creators in your niche
• Partnership Development: Connect with thought leaders and industry experts
• Content Collaboration: Build relationships with complementary brands
• Media Relations: Find journalists and bloggers covering your industry