Bibliothèque Officielle

SDK de vérification d'e-mail pour Go

Le client Go officiel pour EmailVerify.io, offrant des outils de validation d'e-mails et de découverte de prospects à haute concurrence et optimisés pour les performances des systèmes distribués.

Obtenir la clé API

Vous voulez une bibliothèque pour votre langage ? Contactez-nous

sdk-example.worker

Configuration Go Get

Ajoutez le client EmailVerify Go aux dépendances de votre projet.

terminal


                go get github.com/Clustox/emailverifygo

Exemples d'utilisation

1 Vérification en Temps Réel

Vérification d'e-mails haute performance pour Go. Notre SDK est conçu pour être léger et rapide, fournissant des opérations thread-safe pour la validation en temps réel.

import "github.com/Clustox/emailverifygo"

client := emailverifygo.NewClient("your_api_key")
res, err := client.Validate("[email protected]")

if err == nil && res.Status == "valid" {
    fmt.Println("Safe to send!")
}

2 Soumission de Lots Importants

Traitez des ensembles de données massifs sans blocage. Le client batch Go vous permet de soumettre de grandes tranches d'e-mails pour une vérification en arrière-plan.

emails :=[]string{"[email protected]", "[email protected]"}
batch, _ := client.ValidateBatch(emails, "My Task")

// Poll or use webhooks
status, _ := client.GetTaskStatus(batch.TaskID)
if status.State == "finished" {
    results, _ := client.GetTaskResults(batch.TaskID)
    fmt.Printf("Processed %d emails\n", len(results))
}

3 Client & Contexte Avancés

Configuration prête pour l'entreprise. Prend entièrement en charge le modèle de contexte de Go pour les annulations et les délais d'attente.

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

// Advanced config with custom HTTP client
client := emailverifygo.NewClient("key")
client.HTTPClient.Timeout = 10 * time.Second

res, err := client.ValidateWithContext(ctx, "[email protected]")

4 Recherche d'E-mails par IA

Découverte de prospects professionnels. Utilisez notre API Finder pour résoudre les adresses e-mail institutionnelles à partir de noms et de domaines.

lead, err := client.FindEmail("Larry Page", "google.com")

if err == nil && lead.Status == "found" {
    fmt.Printf("Found: %s (Confidence: %d%%)\n", lead.Email, lead.Confidence)
}

5 Correction de Syntaxe en Temps Réel

Minimisez les frictions pour les utilisateurs. Détectez et suggérez automatiquement des corrections pour les fautes de frappe d'e-mail courantes en temps réel.

check, _ := client.ValidateSyntax("[email protected]")
if check.Suggestion != "" {
    fmt.Printf("Typo detected! Did you mean %s?\n", check.Suggestion)
}

6 Vérification Concurrente

Conçu pour la vitesse. Tirez parti des goroutines de Go pour effectuer plusieurs vérifications en temps réel en parallèle.

var wg sync.WaitGroup
emails :=[]string{"[email protected]", "[email protected]", "[email protected]"}

for _, email := range emails {
    wg.Add(1)
    go func(e string) {
        defer wg.Done()
        res, _ := client.Validate(e)
        fmt.Println(res.Status)
    }(email)
}
wg.Wait()

7 Erreurs Robustes et Typées

Gestion gracieuse des erreurs. Chaque échec d'API est renvoyé sous la forme d'un type d'erreur structuré pour une détection précise du mode de défaillance.

res, err := client.Validate(email)
if err != nil {
    if apiErr, ok := err.(*emailverifygo.APIError); ok {
        fmt.Printf("Status: %d, Message: %s", apiErr.Code, apiErr.Message)
    }
}

8 Détection de Spam et de Sécurité

Protégez votre réputation. Détectez et bloquez les services de messagerie jetables et les pièges à spam connus avant qu'ils ne contactent vos serveurs.

res, _ := client.Validate("[email protected]")
if res.IsDisposable || res.IsSpamTrap {
    log.Printf("High risk email: %s", res.Email)
}
fmt.Printf("Provider: %s", res.DomainInfo.Provider)

FAQs

Questions Fréquemment Posées

Le SDK Go est-il thread-safe ?

Oui, le client Go est conçu pour être thread-safe et peut être partagé en toute sécurité entre plusieurs goroutines.

Comment gérer les erreurs dans le SDK Go ?

Le SDK suit le modèle standard de gestion des erreurs Go. Chaque méthode API renvoie un résultat et un objet d'erreur.

Le SDK prend-il en charge le context ?

Oui, notre dernier SDK Go prend en charge la propagation de contexte, vous permettant de gérer efficacement les délais d'attente des requêtes.

Puis-je l'utiliser pour une validation à haute concurrence ?

Absolument. Le SDK Go est optimisé pour les hautes performances et est idéal pour les microservices à haute concurrence.

Vous n'êtes qu'à un clic de listes d'e-mails propres.

Commencez à vérifier vos adresses e-mail instantanément et améliorez la délivrabilité de vos campagnes

Parler aux ventes

* Aucune carte de crédit requise