Email Verification API
Go / Golang 2026

package main

import (
    "context"
    "encoding/json"
    "fmt"
    "net/http"
    "net/url"
    "time"
)

const apiKey = "YOUR_BOUNCEZERO_KEY"

type VerifyResult struct {
    Email          string  `json:"email"`
    Classification string  `json:"classification"`
    Score          float64 `json:"score"`
    IsDeliverable  bool    `json:"is_deliverable"`
    IsCatchAll     bool    `json:"is_catch_all"`
    IsDisposable   bool    `json:"is_disposable"`
}

func verifyEmail(ctx context.Context, email string) (VerifyResult, error) {
    endpoint := "https://api.bouncezero.io/v1/verify?email=" + url.QueryEscape(email)

    req, err := http.NewRequestWithContext(ctx, http.MethodGet, endpoint, nil)
    if err != nil {
        return VerifyResult{}, err
    }
    req.Header.Set("X-Api-Key", apiKey)

    client := &http.Client{Timeout: 15 * time.Second}
    resp, err := client.Do(req)
    if err != nil {
        return VerifyResult{}, err
    }
    defer resp.Body.Close()

    var result VerifyResult
    if err := json.NewDecoder(resp.Body).Decode(&result); err != nil {
        return VerifyResult{}, err
    }
    return result, nil
}

func main() {
    ctx, cancel := context.WithTimeout(context.Background(), 20*time.Second)
    defer cancel()

    result, err := verifyEmail(ctx, "[email protected]")
    if err != nil {
        fmt.Printf("Error: %v\n", err)
        return
    }
    fmt.Printf("Classification: %s | Deliverable: %v | Score: %.2f\n",
        result.Classification, result.IsDeliverable, result.Score)
}

package main

import (
    "context"
    "fmt"
    "sync"
    "time"
)

type job struct {
    index int
    email string
}

type result struct {
    index  int
    email  string
    result VerifyResult
    err    error
}

func bulkVerify(ctx context.Context, emails []string, workers int) []result {
    jobs    := make(chan job, len(emails))
    results := make(chan result, len(emails))

    // Start workers
    var wg sync.WaitGroup
    for i := 0; i < workers; i++ {
        wg.Add(1)
        go func() {
            defer wg.Done()
            for j := range jobs {
                // Honour rate limit: 10 req/s = 100ms between requests per worker
                time.Sleep(100 * time.Millisecond)
                res, err := verifyEmail(ctx, j.email)
                results <- result{index: j.index, email: j.email, result: res, err: err}
            }
        }()
    }

    // Enqueue jobs
    for i, email := range emails {
        jobs <- job{index: i, email: email}
    }
    close(jobs)

    // Wait then close results
    go func() {
        wg.Wait()
        close(results)
    }()

    // Collect
    out := make([]result, 0, len(emails))
    for r := range results {
        out = append(out, r)
    }
    return out
}

func main() {
    emails := []string{
        "[email protected]",
        "[email protected]",
        "invalid@@broken.com",
    }

    ctx, cancel := context.WithTimeout(context.Background(), 5*time.Minute)
    defer cancel()

    // 5 workers - adjust to stay within your plan's rate limit
    results := bulkVerify(ctx, emails, 5)

    for _, r := range results {
        if r.err != nil {
            fmt.Printf("[%d] %s - ERROR: %v\n", r.index, r.email, r.err)
            continue
        }
        fmt.Printf("[%d] %s - %s (deliverable: %v)\n",
            r.index, r.email, r.result.Classification, r.result.IsDeliverable)
    }
}

func verifyWithRetry(ctx context.Context, email string, maxRetries int) (VerifyResult, error) {
    delay := 500 * time.Millisecond
    for attempt := 0; attempt <= maxRetries; attempt++ {
        result, err := verifyEmail(ctx, email)
        if err == nil {
            return result, nil
        }
        if ctx.Err() != nil {
            return VerifyResult{}, ctx.Err() // context cancelled or deadline exceeded
        }
        if attempt < maxRetries {
            select {
            case <-time.After(delay):
                delay *= 2 // exponential backoff
            case <-ctx.Done():
                return VerifyResult{}, ctx.Err()
            }
        }
    }
    return VerifyResult{}, fmt.Errorf("max retries exceeded for %s", email)
}

package main

import (
    "context"
    "net/http"
    "time"

    "github.com/gin-gonic/gin"
)

// EmailVerifyMiddleware rejects invalid/disposable emails on signup endpoints.
func EmailVerifyMiddleware() gin.HandlerFunc {
    return func(c *gin.Context) {
        var body struct {
            Email string `json:"email" binding:"required,email"`
        }
        if err := c.ShouldBindJSON(&body); err != nil {
            c.AbortWithStatusJSON(http.StatusBadRequest, gin.H{"error": "invalid request"})
            return
        }

        ctx, cancel := context.WithTimeout(c.Request.Context(), 10*time.Second)
        defer cancel()

        result, err := verifyEmail(ctx, body.Email)
        if err != nil {
            // Fail open: don't block signup on API timeout
            c.Set("email_verification_skipped", true)
            c.Next()
            return
        }

        if result.IsDisposable {
            c.AbortWithStatusJSON(http.StatusUnprocessableEntity, gin.H{
                "error": "Disposable email addresses are not allowed.",
            })
            return
        }
        if result.Classification == "invalid" {
            c.AbortWithStatusJSON(http.StatusUnprocessableEntity, gin.H{
                "error": "This email address does not appear to exist.",
            })
            return
        }

        c.Set("email_classification", result.Classification)
        c.Next()
    }
}

func main() {
    r := gin.Default()
    r.POST("/signup", EmailVerifyMiddleware(), func(c *gin.Context) {
        c.JSON(http.StatusCreated, gin.H{"message": "Account created"})
    })
    r.Run(":8080")
}