Email Verification API
Go (Golang) 2026

package main

import (
	"bytes"
	"encoding/json"
	"fmt"
	"net/http"
	"os"
	"time"
)

type VerifyResult struct {
	Email          string `json:"email"`
	Score          int    `json:"score"`
	Classification string `json:"classification"` // "valid" | "invalid"
	IsDeliverable  bool   `json:"is_deliverable"`
	RiskLevel      string `json:"risk_level"`
	Checks         struct {
		NotDisposable *bool `json:"not_disposable"`
	} `json:"checks"`
	Metadata struct {
		InternalClassification string `json:"internal_classification"`
		Refunded               bool   `json:"refunded"`
		CatchAllUnresolved     bool   `json:"catch_all_unresolved"`
	} `json:"metadata"`
}

var httpClient = &http.Client{Timeout: 30 * time.Second}

func VerifyEmail(email, apiKey string) (*VerifyResult, error) {
	endpoint := "https://api.bouncezero.io/api/v1/verify"
	payload, _ := json.Marshal(map[string]string{"email": email})

	req, err := http.NewRequest("POST", endpoint, bytes.NewReader(payload))
	if err != nil {
		return nil, err
	}
	req.Header.Set("X-API-Key", apiKey)
	req.Header.Set("Content-Type", "application/json")

	resp, err := httpClient.Do(req)
	if err != nil {
		return nil, err
	}
	defer resp.Body.Close()
	if resp.StatusCode != http.StatusOK {
		return nil, fmt.Errorf("bouncezero: HTTP %d", resp.StatusCode)
	}

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

func main() {
	apiKey := os.Getenv("BOUNCEZERO_API_KEY")
	result, err := VerifyEmail("[email protected]", apiKey)
	if err != nil {
		fmt.Fprintf(os.Stderr, "error: %v\n", err)
		os.Exit(1)
	}
	fmt.Printf("classification: %s | score: %d | detail: %s | refunded: %v\n",
		result.Classification, result.Score,
		result.Metadata.InternalClassification, result.Metadata.Refunded)
}

package main

import (
	"fmt"
	"sync"
)

const numWorkers = 20

type Job struct {
	Email string
}

type Result struct {
	Email  string
	Result string
	Error  error
}

func worker(apiKey string, jobs <-chan Job, results chan<- Result, wg *sync.WaitGroup) {
	defer wg.Done()
	for job := range jobs {
		v, err := VerifyEmail(job.Email, apiKey)
		if err != nil {
			results <- Result{Email: job.Email, Error: err}
			continue
		}
		results <- Result{Email: job.Email, Result: v.Classification}
	}
}

func VerifyBatch(emails []string, apiKey string) []Result {
	jobs    := make(chan Job, len(emails))
	results := make(chan Result, len(emails))

	var wg sync.WaitGroup
	for i := 0; i < numWorkers; i++ {
		wg.Add(1)
		go worker(apiKey, jobs, results, &wg)
	}

	for _, email := range emails {
		jobs <- Job{Email: email}
	}
	close(jobs)

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

	var out []Result
	for r := range results {
		out = append(out, r)
	}
	return out
}

func main() {
	emails := []string{"[email protected]", "[email protected]", "invalid@"}
	apiKey := "YOUR_API_KEY"
	results := VerifyBatch(emails, apiKey)
	for _, r := range results {
		if r.Error != nil {
			fmt.Printf("ERROR %s: %v\n", r.Email, r.Error)
		} else {
			fmt.Printf("%-35s %s\n", r.Email, r.Result)
		}
	}
}

package main

import (
	"net/http"
	"os"

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

func EmailVerificationMiddleware() gin.HandlerFunc {
	apiKey := os.Getenv("BOUNCEZERO_API_KEY")
	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
		}

		result, err := VerifyEmail(body.Email, apiKey)
		if err != nil {
			// fail-open: API unreachable > allow the request
			c.Set("email_verified", false)
			c.Next()
			return
		}

		// refunded = could not be verified; fail open on those instead of blocking
		if result.Classification == "invalid" && !result.Metadata.Refunded {
			c.AbortWithStatusJSON(http.StatusUnprocessableEntity, gin.H{
				"error":   "invalid_email",
				"message": "Please use a valid work email address.",
			})
			return
		}

		c.Set("email", body.Email)
		c.Set("email_verified", true)
		c.Next()
	}
}

func main() {
	r := gin.Default()
	r.POST("/signup", EmailVerificationMiddleware(), func(c *gin.Context) {
		email, _ := c.Get("email")
		c.JSON(http.StatusOK, gin.H{"status": "ok", "email": email})
	})
	r.Run(":8080")
}