Validatore e-mail singolo - Tempo reale (v2)

Below you will find the instructions on how to use our API, it's very easy to use and requires SSL. The API requires that you have an active credit balance and will never consume a credit for any unknown result. This endpoint can be called asynchronously and is currently not rate limited.

Per testare o API senza utilizzare crediti: utilizzare le e-mail fornite nel nostro Modalità sandbox (v2)

Il tempo di risposta per la nostra API è compreso tra un secondo e 70 secondi. Poiché le API sono pensate per essere veloci per natura, limitiamo la quantità di tempo che dedichiamo alla convalida di un indirizzo email. Quindi, se incontriamo un server di posta lento o un server di posta con un algoritmo di greylisting, otterrai un risultato sconosciuto. Puoi sempre riconvalidare tali condizioni, caricando un file nel file validatore di email in blocco .

In media il 96-98% di tutti i domini tornerà tra 1 e 5 secondi, ci sono una manciata di domini che eseguono Postfix / Dovecot che hanno un tempo di connessione di 20 secondo per le convalide in tempo reale e un piccola percentuale frazionaria di altri domini che sono molto lenti a rispondere alle richieste SMTP. Tutti i principali ISP torneranno tra 1 e 3 secondi, che di solito è la maggior parte della distribuzione della posta elettronica.

- GET / v2 / validate

URL API: https://api.zerobounce.net/v2/validate

Below you will find the instructions on how to use our API, it's very easy to use and requires SSL. The API requires that you have an active credit balance and will never consume a credit for any unknown result. This endpoint can be called asynchronously and is currently not rate limited.

Parametri URL

  • Parametro
    Descrizione
  • E-MAIL
    L'indirizzo e-mail che desideri convalidare
  • indirizzo ip
    L'indirizzo IP da cui l'email è stata registrata (può essere vuoto, ma il parametro è richiesto)
  • api_key
    La tua chiave API, che si trova nel tuo account.

Se vuoi chiamare l'API dal tuo browser per testarla, tutto ciò che devi fare è sostituire l'API KEY con la tua chiave:

  • https://api.zerobounce.net/v2/validate?api_key=replacewithyours&email=valid@example.com&ip_address=156.124.12.145

Per verificare un indirizzo e-mail, utilizza i seguenti codici per le seguenti lingue:

  • Visual Basic
  • C#
  • PHP
  • Giava
  • Pitone
  • Veloce
  • Obiettivo C
  • Android Java

        
  'Librerie API complete e wrapper sono disponibili qui: 
  ' https://www.zerobounce.net/docs/zerobounce-api-wrappers/#api_wrappers__v2__dot_net

  PROVARE
    Fioco api_key Come Corda = "La tua chiave segreta"
    Fioco emailToValidate Come Corda = "example@example.com"
    Fioco ip_address = "" "Può essere vuoto, ma è necessario un parametro nella chiamata API
    Fioco responseString Come Corda = ""
  
    Fioco apiURL Come Corda = "https://api.zerobounce.net/v2/validate?api_key=" & api_key & "& email =" &  HttpUtility.UrlEncode(emailToValidate) & "& indirizzo_ip =" & Sistema.Net.WebUtility.UrlEncode(ip_address)
  
    Fioco request Come HttpWebRequest = Directcast(WebRequest.Create(apiURL), HttpWebRequest)
    request.Tempo scaduto = 150000
    request.Method = "OTTENERE"
  
    Utilizzando response Come WebResponse = request.GetResponse()
        response.GetResponseStream().ReadTimeout = 20000
        Utilizzando ostream Come Nuovo StreamReader(response.GetResponseStream())
            responseString = ostream.ReadToEnd()
        Fine Utilizzando
    Fine Utilizzando
  Catturare ex Come exception
  'Eccezione di cattura - Tutti gli errori verranno visualizzati qui - se ci sono problemi con l'API
  Fine PROVARE
      

// Le librerie e i wrapper API completi sono disponibili qui: 
// https://www.zerobounce.net/docs/zerobounce-api-wrappers/#api_wrappers__v2__dot_net
// https://www.zerobounce.net/docs/zerobounce-api-wrappers/#api_wrappers__v2__c-sharp

PROVARE {
  Corda api_key = "La tua chiave segreta";
  Corda emailToValidate = "example@example.com";
  Corda ip_address = "" // Può essere vuoto, ma il parametro è richiesto nella chiamata API
  
  Corda responseString = "";
  
  Corda apiURL = "https://api.zerobounce.net/v2/validate?api_key=" + api_key + "& email =" +  HttpUtility.Urlencode(emailToValidate) + "& indirizzo_ip =" + HttpUtility.Urlencode(ip_address);
  
  
      Httpwebrequest request = (HttpWebRequest)WebRequest.creare(apiURL);
      request.Timeout = 150000;
      request.Method = "OTTENERE";
  
      Utilizzando (Webresponse response = request.GetResponse()) {
          response.Getresponsestream().ReadTimeout = 20000;
          Utilizzando (Streamreader ostream = Nuovo Streamreader(response.Getresponsestream())) {
              responseString = ostream.Readtoend();
          }
      }
      } Catturare (exception ex) {
  // Eccezione di cattura: qui verranno visualizzati tutti gli errori, in caso di problemi con l'API
  }
      

  <?php

  // Le librerie e i wrapper API completi sono disponibili qui: 
  // https://www.zerobounce.net/docs/zerobounce-api-wrappers/#api_wrappers__v2__php

  // imposta la chiave api e l'e-mail da convalidare
  $ api_key = "La tua chiave segreta";
  $ emailToValidate = 'example@example.com';
  $ IPToValidate = '99.123.12.122';
  // usa curl per fare la richiesta
  $ url = 'https://api.zerobounce.net/v2/validate?api_key='.$ api_key."& email =".Urlencode($ emailToValidate)."& ip_address =".Urlencode($ IPToValidate);

  $ ch = curl_init($ url);
  //PHP 5.5.19 e versioni successive supportano TLS  1.2
  curl_setopt($ ch, CURLOPT_SSLVERSION, 6);
  curl_setopt($ ch, CURLOPT_RETURNTRANSFER, Vero);
  curl_setopt($ ch, CURLOPT_CONNECTTIMEOUT, 15); 
  curl_setopt($ ch, CURLOPT_TIMEOUT, 150); 
  $ risposta = curl_exec($ ch);
  curl_close($ ch);

  // decodifica la risposta json
  $ json = json_decode($ risposta, Vero);
  ?>
      
      


  // Le librerie e i wrapper API completi sono disponibili qui: 
  //https://www.zerobounce.net/docs/zerobounce-api-wrappers/#api_wrappers__v2__java

  importare Giava.io.Bufferedreader;
  importare Giava.io.Inputstreamreader;
  importare Giava.netto.Httpurlconnection;
  importare Giava.netto.URL;

  Pubblico Classe La mia classe {

      Pubblico statico vuoto principale(Corda[] args){

          Corda key = "La tua chiave segreta";
          Corda email = "example@example.com";
          Corda ip = "99.123.12.122"; // l'indirizzo ip può essere vuoto
          Corda targetURL = "https://api.zerobounce.net/v2/validate?api_key="+key+"& email ="+email+"& indirizzo_ip ="+ip;


          Httpurlconnection connection = nullo;
          finale Corda USER_AGENT = "Mozilla / 5.0";

          PROVARE {
              url url = Nuovo url(targetURL);
              connection = (Httpurlconnection) url.connessione aperta();
              connection.setrequestmethod("OTTENERE");
              connection.addrequestproperty("user-agent", USER_AGENT);
              connection.setusecaches(Falso);
              connection.setdooutput(Vero);

              Bufferedreader in = Nuovo Bufferedreader(
                      Nuovo Inputstreamreader(connection.getinputstream()));
              Corda inputLine;
              Stringbuffer response = Nuovo Stringbuffer();

              mentre ((inputLine = in.linea di lettura()) != nullo) {
                  response.aggiungere(inputLine);
              }
              in.vicino();

              // stampa il risultato
              Sistema.out.println(response.toString());

          } Catturare (Eccezione e) {
              e.printstacktrace();
          } finalmente {
              Se (connection != nullo) {
                  connection.disconnect();
              }
          }

      }
  }
      

  # Librerie e wrapper API completi sono disponibili qui: 
  # https://www.zerobounce.net/docs/zerobounce-api-wrappers/#api_wrappers__v2__python
  
  url = "https://api.zerobounce.net/v2/validate"
  api_key = "La tua chiave segreta"
  email = "example@example.com"
  ip_address = "99.123.12.122" #ip_address può essere vuoto
  
  params = {"e-mail": email, "api_key": api_key, "indirizzo ip":ip_address}
  
  response = requests.get(url, params=params)
  
  # Stampa il json restituito
  stampare json.loads(response.content)
  
      


  // Le librerie e i wrapper API completi sono disponibili qui: 
  // https://www.zerobounce.net/docs/zerobounce-api-wrappers/#api_wrappers__v2__IOS

  permettere key = "La tua chiave segreta"
  permettere email = "example@example.com"
  permettere ip = "99.123.12.122" // l'indirizzo ip può essere vuoto
  permettere url = url(string: Corda(format: "https://api.zerobounce.net/v2/validate?api_key=%@&email=%@&ip_address=%@", key, email, ip))
  permettere task = Urlsession.shared.datatask(with: url!) { (data, response, error) in
      Se error != zero {
          NSLog("Errore (stringa (che descrive: errore))")
      } altro {
          fare {
              permettere parsedData = PROVARE Jsonserialization.jsonobject(with: data!) Come! [Corda:Qualunque]
              per (key, value) in parsedData {
                  NSLog("(chiave) = (valore)")
              }
          } Catturare {
              stampare("Errore durante la deserializzazione di JSON: (errore)")
          }
      }
  }
  task.curriculum vitae()      
      


  // Le librerie e i wrapper API completi sono disponibili qui: 
  // https://www.zerobounce.net/docs/zerobounce-api-wrappers/#api_wrappers__v2__IOS

  NSString *key = @ "La tua chiave segreta";
  NSString *email = @"example@example.com";
  NSString *ip = @"99.123.12.122"; // l'indirizzo ip può essere vuoto
  
  NSString *urlString = [NSString stringWithFormat:@"https://api.zerobounce.net/v2/validate?api_key=%@&email=%@&ip_address=%@", key, email, ip];
  
  __block NSURL *url = [NSURL URLWithString:urlString];
  
  dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
  
      NSData *response = [NSData dataWithContentsOfURL:url];
      NSDictionary *arrResponse = nil;
      Se(response!=nil)
      {
          arrResponse = [NSJSONSerialization JSONObjectWithData: response options:kNilOptions error:nil];
      }
      dispatch_async(dispatch_get_main_queue(), ^(vuoto) {
          per(NSString *key in [arrResponse allKeys]) {
              NSLog(@"%@: %@",key,[arrResponse objectForKey:key]);
          }
  // callback (nil, arr);
      });
  });
      



  // Le librerie e i wrapper API completi sono disponibili qui: 
  // https://www.zerobounce.net/docs/zerobounce-api-wrappers/#api_wrappers__v2__android

  // Aggiungi a build.gradle (App) nella parentesi "android":
  useLibrary "org.apache.http.legacy"
  
  Esempio:
  
  android {
      compileSdkVersion 25
      useLibrary "org.apache.http.legacy"
  }
  
  //-----------------------------------
  // Nome file: JsonParser.java
  
  
  importare androide.os.Asynctask;
  importare org.json.jsonobject;
  importare Giava.util.Iteratore;
  
  Pubblico Classe Attività principale si estende Appcompatactivity {
  
      @Oltrepassare
      protetto vuoto oncreate(Impacchettare savedInstanceState) {
          super.oncreate(savedInstanceState);
  
          Nuovo Asynctaskparsejson().eseguire();
      }
  }
  
  Pubblico Classe Asynctaskparsejson si estende Asynctask<Corda, Corda, Corda> {
  
      Corda key = "La tua chiave segreta";
      Corda email = "example@example.com";
      Corda ip = "99.123.12.122"; // l'indirizzo ip può essere vuoto
      Corda url = "https://api.zerobounce.net/v2/validate?api_key="+key+"& email ="+email+"& indirizzo_ip ="+ip;
  
      @Oltrepassare
      protetto vuoto onpreexecute() {
      }
  
      @Oltrepassare
      protetto Corda doinbackground(Corda... arg0) {
  
          Jsonparser jParser = Nuovo Jsonparser();
          jsonobject json = jParser.getjsonfromurl(url);
          Iteratore keys = json.chiavi();
          mentre( keys.hasnext() ) {
              Corda key = (Corda)keys.il prossimo();
              PROVARE {
                  Sistema.out.println("ZeroBounce:"+key+" = " +json.ottenere(key).toString());
              }
              Catturare (Eccezione e){}
          }
  
          Ritorno nullo;
      }
      @Oltrepassare
      protetto vuoto onpostexecute(Corda strFromDoInBg) {}
  }
  
  //----------------------------------
  // Nome file: MainActivity.java
  
  pacchetto com.Zerobounce.zbapiandroid;
  
  importare Giava.io.Bufferedreader;
  importare Giava.io.Ioexception;
  importare Giava.io.Inputstream;
  importare Giava.io.Inputstreamreader;
  importare Giava.io.Eccezione di codifica non supportata;
  
  importare org.apache.http.Httpentity;
  importare org.apache.http.Http: //presponse;
  importare org.apache.http.cliente.Clientprotocolexception;
  importare org.apache.http.cliente.metodi.Httpget;
  importare org.apache.http.impl.cliente.Defaulthttpclient;
  importare org.json.Jsonexception;
  importare org.json.jsonobject;
  
  importare androide.util.Ceppo;
  
  Pubblico Classe Jsonparser {
  
      finale Corda TAG = "jsonparser.java";
  
      statico Inputstream is = nullo;
      statico jsonobject jObj = nullo;
      statico Corda json = "";
  
      Pubblico jsonobject getjsonfromurl(Corda url) {
  
          PROVARE {
  
              Defaulthttpclient httpClient = Nuovo Defaulthttpclient();
              Httpget httpGet = Nuovo Httpget(url);
  
              Http: //presponse httpResponse = httpClient.eseguire(httpGet);
              Httpentity httpEntity = httpResponse.getentity();
              is = httpEntity.getcontent();
  
          } Catturare (Eccezione di codifica non supportata e) {
              e.printstacktrace();
          } Catturare (Clientprotocolexception e) {
              e.printstacktrace();
          } Catturare (Ioexception e) {
              e.printstacktrace();
          }
  
          PROVARE {
  
              Bufferedreader reader = Nuovo Bufferedreader(Nuovo Inputstreamreader(is, "iso- 8859-1"), 8);
              Stringbuilder sb = Nuovo Stringbuilder();
              Corda line = nullo;
              mentre ((line = reader.linea di lettura()) != nullo) {
                  sb.aggiungere(line + "
");
              }
              is.vicino();
              json = sb.toString();
  
          } Catturare (Eccezione e) {
              Ceppo.e(TAG, "Errore durante la conversione del risultato" + e.toString());
          }
  
          PROVARE {
              jObj = Nuovo jsonobject(json);
          } Catturare (Jsonexception e) {
              Ceppo.e(TAG, "Errore durante l'analisi dei dati" + e.toString());
          }
  
          Ritorno jObj;
      }
    }
      

Risposta riuscita

      
  {
    "indirizzo":"flowerjill@aol.com",
    "stato":"valido",
    "sub_status":"",
    "free_email":Vero,
    "intendevi":nullo,
    "account":"flowerjill",
    "dominio":"aol.com",
    "domain_age_days": "8426",
    "smtp_provider":"yahoo",
    "mx_record":"mx-aol.mail.gm0.yahoodns.net",
    "mx_found": Vero,
    "nome di battesimo":"jill",
    "cognome":"boccale",
    "genere":"femmina",
    "nazione":"Stati Uniti",
    "regione":"Florida",
    "città":"west palm beach",
    "cap":"33401",
    "processed_at":"2017-04-01 02:48:02.592"
    }
      

Risposta all'errore

      
      {"errore":"Chiave API non valida o il tuo account ha esaurito i crediti"}
      // Esempio di risposta in caso di errore utilizzando l'API con uno dei metodi Get
      

L'API restituirà questi risultati in un formato JSON utilizzando il metodo "Validate".

Proprietà JSON

  • Proprietà
    Descrizione
  • indirizzo
    L'indirizzo email che stai convalidando.
  • stato
    [valido, non valido, generico, sconosciuto, spamtrap, abuso, do_not_mail]
  • sub_status
    [antispam_system,
    greylist, mail_server_temporary_error, forcible_disconnect, mail_server_did_not_respond, timeout_exceeded, failed_smtp_connection, mailbox_quota_exceeded, exception_occurred, possible_traps, role_based, global_suppression, mailbox_not_found, no_dns_entries, failed_syntax_check, possible_typo, unroutable_ip_address, leading_period_removed, does_not_accept_mail, alias_address, role_based_catch_all, monouso, tossico]
  • account
    La parte dell'indirizzo e-mail prima del simbolo "@".
  • Dominio
    La parte dell'indirizzo e-mail dopo il simbolo "@".
  • intendevi
    Correzione suggestiva per un errore di battitura e-mail
  • domain_age_days
    Età del dominio di posta elettronica in giorni o [null].
  • free_email
    [vero / falso] Se l'email proviene da un provider gratuito.
  • mx_found
    [true / false] Il dominio ha un record MX.
  • mx_record
    Il record MX preferito del dominio
  • smtp_provider
    Il provider SMTP dell'email o [null] [BETA].
  • nome di battesimo
    Il nome del proprietario dell'email se disponibile o [null].
  • cognome
    Il cognome del proprietario dell'email se disponibile o [null].
  • genere
    Il sesso del proprietario dell'email se disponibile o [null].
  • città
    The city of the IP passed in or [null]
  • regione
    The region/state of the IP passed in or [null]
  • cap
    The zipcode of the IP passed in or [null]
  • nazione
    The country of the IP passed in or [null]
  • processed_at
    L'ora UTC in cui è stata convalidata l'email.