Validador único de correo electrónico: en tiempo real (v2)

A continuación encontrará las instrucciones sobre cómo usar nuestra API, es muy fácil de usar y requiere SSL. La API requiere que tenga un saldo de crédito activo y nunca consumirá un crédito por ningún resultado desconocido.

Para probar o API sin usar créditos: utilice los correos electrónicos proporcionados en nuestro Modo Sandbox (v2)

El tiempo de respuesta para nuestra API es de entre un segundo y 70 segundos. Dado que las API están destinadas a ser rápidas por naturaleza, limitamos la cantidad de tiempo que pasamos validando una dirección de correo electrónico. Entonces, si nos encontramos con un servidor de correo lento o un servidor de correo con un algoritmo de lista gris, obtendrá un resultado desconocido. Siempre puede volver a validar esas condiciones, cargando un archivo en validador de correo electrónico masivo .

En promedio, el 96-98% de todos los dominios volverá en 1 a 5 segundos, hay un puñado de dominios que se ejecutan en Postfix / Dovecot que tienen un tiempo de conexión de 20 segundos para validaciones en tiempo real y muy pequeño porcentaje fraccionario de otros dominios que responden muy lentamente a las consultas SMTP. Todo el ISP principal volverá en 1 a 3 segundos, que generalmente es la mayoría de la distribución de correo electrónico.

- GET / v2 / validar

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

A continuación encontrará las instrucciones sobre cómo usar nuestra API, es muy fácil de usar y requiere SSL. La API requiere que tenga un saldo de crédito activo y nunca consumirá un crédito por ningún resultado desconocido.

Parámetros URL

  • Parámetro
    Descripción
  • CORREO ELECTRÓNICO
    La dirección de correo electrónico que desea validar
  • dirección ip
    La dirección IP desde la que se registró el correo electrónico (puede estar en blanco, pero se requiere un parámetro)
  • clave api
    Su clave API, que se encuentra en su cuenta.

Si desea llamar a la API desde su navegador para probarla, todo lo que necesita hacer es reemplazar la CLAVE API con su clave:

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

Para verificar una dirección de correo electrónico, use los siguientes códigos para los siguientes idiomas:

  • Visual básico
  • C#
  • PHP
  • Java
  • Pitón
  • Rápido
  • C objetivo
  • Android java

        
  'Las bibliotecas y envoltorios API completos se pueden encontrar aquí: 
  ' https://www.zerobounce.net/docs/zerobounce-api-wrappers/#api_wrappers__v2__dot_net

  Tratar
    Oscuro api_key COMO Cuerda = "Tu llave secreta"
    Oscuro emailToValidate COMO Cuerda = "example@example.com"
    Oscuro ip_address = "" 'Puede estar en blanco, pero se requiere un parámetro en la llamada a la API
    Oscuro responseString COMO Cuerda = ""
  
    Oscuro apiURL COMO Cuerda = "https://api.zerobounce.net/v2/validate?api_key=" & api_key & "& email =" &  HttpUtility.UrlEncode(emailToValidate) & "& ip_address =" & Sistema.Net.WebUtility.UrlEncode(ip_address)
  
    Oscuro request COMO HttpWebRequest = Difusión directa(WebRequest.Create(apiURL), HttpWebRequest)
    request.Se acabó el tiempo = 150000
    request.Method = "OBTENER"
  
    Utilizando response COMO WebResponse = request.GetResponse()
        response.GetResponseStream().ReadTimeout = 20000
        Utilizando ostream COMO NUEVO StreamReader(response.GetResponseStream())
            responseString = ostream.ReadToEnd()
        Fin Utilizando
    Fin Utilizando
  Captura ex COMO exception
  'Excepción de captura: todos los errores se mostrarán aquí, si hay problemas con la API
  Fin Tratar
      

// Las bibliotecas y envoltorios API completos se pueden encontrar aquí: 
// 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

Tratar {
  Cuerda api_key = "Tu llave secreta";
  Cuerda emailToValidate = "example@example.com";
  Cuerda ip_address = "" // Puede estar en blanco, pero se requiere un parámetro en la Llamada API
  
  Cuerda responseString = "";
  
  Cuerda apiURL = "https://api.zerobounce.net/v2/validate?api_key=" + api_key + "& email =" +  HttpUtility.Urlencode(emailToValidate) + "& ip_address =" + HttpUtility.Urlencode(ip_address);
  
  
      Httpwebrequest request = (HttpWebRequest)WebRequest.crear(apiURL);
      request.Timeout = 150000;
      request.Method = "OBTENER";
  
      Utilizando (Respuesta web response = request.Obtener una respuesta()) {
          response.Getresponsestream().ReadTimeout = 20000;
          Utilizando (Lector de corriente ostream = NUEVO Lector de corriente(response.Getresponsestream())) {
              responseString = ostream.Readtoend();
          }
      }
      } Captura (exception ex) {
  // Excepción de captura: todos los errores se mostrarán aquí, si hay problemas con la API
  }
      

  <?php

  // Las bibliotecas y envoltorios API completos se pueden encontrar aquí: 
  // https://www.zerobounce.net/docs/zerobounce-api-wrappers/#api_wrappers__v2__php

  // establece la clave de la api y el correo electrónico para validar
  $ api_key = 'Tu clave secreta';
  $ emailToValidate = 'example@example.com';
  $ IPToValidate = '99.123.12.122';
  // usa curl para hacer la solicitud
  $ 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 y superior tiene soporte para TLS  1.2
  curl_setopt($ ch, CURLOPT_SSLVERSION, 6);
  curl_setopt($ ch, CURLOPT_RETURNTRANSFER, Cierto);
  curl_setopt($ ch, CURLOPT_CONNECTTIMEOUT, 15); 
  curl_setopt($ ch, CURLOPT_TIMEOUT, 150); 
  $ respuesta = curl_exec($ ch);
  curl_close($ ch);

  // decodifica la respuesta json
  $ json = json_decode($ respuesta, Cierto);
  ?>
      
      


  // Las bibliotecas y envoltorios API completos se pueden encontrar aquí: 
  //https://www.zerobounce.net/docs/zerobounce-api-wrappers/#api_wrappers__v2__java

  importar Java.io.Lector tamponado;
  importar Java.io.Inputstreamreader;
  importar Java.red.Httpurlconnection;
  importar Java.red.URL;

  Público Clase Mi clase {

      Público estático vacío principal(Cuerda[] args){

          Cuerda key = "Tu llave secreta";
          Cuerda email = "example@example.com";
          Cuerda ip = "99.123.12.122"; // la dirección ip puede estar en blanco
          Cuerda targetURL = "https://api.zerobounce.net/v2/validate?api_key="+key+"& email ="+email+"& ip_address ="+ip;


          Httpurlconnection connection = nulo;
          final Cuerda USER_AGENT = "Mozilla / 5.0";

          Tratar {
              url url = NUEVO url(targetURL);
              connection = (Httpurlconnection) url.conexión abierta();
              connection.setrequestmethod("OBTENER");
              connection.addrequestproperty("Agente de usuario", USER_AGENT);
              connection.setusecaches(Falso);
              connection.setdooutput(Cierto);

              Lector tamponado in = NUEVO Lector tamponado(
                      NUEVO Inputstreamreader(connection.getinputstream()));
              Cuerda inputLine;
              Stringbuffer response = NUEVO Stringbuffer();

              mientras ((inputLine = in.readline()) != nulo) {
                  response.adjuntar(inputLine);
              }
              in.cerrar();

              // imprimir resultado
              Sistema.out.println(response.toString());

          } Captura (Excepción e) {
              e.printstacktrace();
          } finalmente {
              Si (connection != nulo) {
                  connection.desconectar();
              }
          }

      }
  }
      

  # Las bibliotecas y envoltorios API completos se pueden encontrar aquí: 
  # https://www.zerobounce.net/docs/zerobounce-api-wrappers/#api_wrappers__v2__python
  
  url = "https://api.zerobounce.net/v2/validate"
  api_key = "Tu llave secreta"
  email = "example@example.com"
  ip_address = "99.123.12.122" #ip_address puede estar en blanco
  
  params = {"correo electrónico": email, "clave api": api_key, "dirección ip":ip_address}
  
  response = requests.get(url, params=params)
  
  # Imprime el json devuelto
  impresión json.loads(response.content)
  
      


  // Las bibliotecas y envoltorios API completos se pueden encontrar aquí: 
  // https://www.zerobounce.net/docs/zerobounce-api-wrappers/#api_wrappers__v2__IOS

  dejar key = "Tu llave secreta"
  dejar email = "example@example.com"
  dejar ip = "99.123.12.122" // la dirección ip puede estar en blanco
  dejar url = url(string: Cuerda(format: "https://api.zerobounce.net/v2/validate?api_key=%@&email=%@&ip_address=%@", key, email, ip))
  dejar task = Sesión.shared.tarea de datos(with: url!) { (data, response, error) en
      Si error != nulo {
          Nslog("Error (Cadena (que describe: error))")
      } más {
          hacer {
              dejar parsedData = Tratar JSONSerialización.jsonobject(with: data!) COMO! [Cuerda:Alguna]
              para (key, value) en parsedData {
                  Nslog("(clave) = (valor)")
              }
          } Captura {
              impresión("Error al deserializar JSON: (error)")
          }
      }
  }
  task.currículum()      
      


  // Las bibliotecas y envoltorios API completos se pueden encontrar aquí: 
  // https://www.zerobounce.net/docs/zerobounce-api-wrappers/#api_wrappers__v2__IOS

  NSString *key = @ "Tu clave secreta";
  NSString *email = @"example@example.com";
  NSString *ip = @"99.123.12.122"; // la dirección ip puede estar en blanco
  
  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;
      Si(response!=nil)
      {
          arrResponse = [NSJSONSerialization JSONObjectWithData: response options:kNilOptions error:nil];
      }
      dispatch_async(dispatch_get_main_queue(), ^(vacío) {
          para(NSString *key en [arrResponse allKeys]) {
              Nslog(@"%@: %@",key,[arrResponse objectForKey:key]);
          }
  // devolución de llamada (nil, arr);
      });
  });
      



  // Las bibliotecas y envoltorios API completos se pueden encontrar aquí: 
  // https://www.zerobounce.net/docs/zerobounce-api-wrappers/#api_wrappers__v2__android

  // Añadir a build.gradle (aplicación) en el soporte "android":
  useLibrary 'org.apache.http.legacy'
  
  Ejemplo:
  
  android {
      compileSdkVersion 25
      useLibrary 'org.apache.http.legacy'
  }
  
  //-----------------------------------
  // Nombre de archivo: JsonParser.java
  
  
  importar androide.os.Asynctask;
  importar org.json.jsonobject;
  importar Java.util.Iterador;
  
  Público Clase Actividad principal se extiende Appcompatactivity {
  
      @Anular
      protegido vacío crear(Haz savedInstanceState) {
          súper.crear(savedInstanceState);
  
          NUEVO Asynctaskparsejson().ejecutar();
      }
  }
  
  Público Clase Asynctaskparsejson se extiende Asynctask<Cuerda, Cuerda, Cuerda> {
  
      Cuerda key = "Tu llave secreta";
      Cuerda email = "example@example.com";
      Cuerda ip = "99.123.12.122"; // la dirección ip puede estar en blanco
      Cuerda url = "https://api.zerobounce.net/v2/validate?api_key="+key+"& email ="+email+"& ip_address ="+ip;
  
      @Anular
      protegido vacío onpreexecute() {
      }
  
      @Anular
      protegido Cuerda Doinbackground(Cuerda... arg0) {
  
          Jsonparser jParser = NUEVO Jsonparser();
          jsonobject json = jParser.getjsonfromurl(url);
          Iterador keys = json.llaves();
          mientras( keys.hasnext() ) {
              Cuerda key = (Cuerda)keys.próximo();
              Tratar {
                  Sistema.out.println("ZeroBounce:"+key+" = " +json.obtener(key).toString());
              }
              Captura (Excepción e){}
          }
  
          Regreso nulo;
      }
      @Anular
      protegido vacío onpostexecute(Cuerda strFromDoInBg) {}
  }
  
  //----------------------------------
  // Nombre de archivo: MainActivity.java
  
  paquete com.Cero rebote.zbapiandroid;
  
  importar Java.io.Lector tamponado;
  importar Java.io.Ioexception;
  importar Java.io.Flujo de entrada;
  importar Java.io.Inputstreamreader;
  importar Java.io.Excepción de notificación sin soporte;
  
  importar org.apache.http.Httpentity;
  importar org.apache.http.Httpresponse;
  importar org.apache.http.cliente.Clienteprotocolexcepción;
  importar org.apache.http.cliente.métodos.Httpget;
  importar org.apache.http.impl.cliente.Cliente predeterminado;
  importar org.json.Jsonexception;
  importar org.json.jsonobject;
  
  importar androide.util.Iniciar sesión;
  
  Público Clase Jsonparser {
  
      final Cuerda TAG = "jsonparser.java";
  
      estático Flujo de entrada is = nulo;
      estático jsonobject jObj = nulo;
      estático Cuerda json = "";
  
      Público jsonobject getjsonfromurl(Cuerda url) {
  
          Tratar {
  
              Cliente predeterminado httpClient = NUEVO Cliente predeterminado();
              Httpget httpGet = NUEVO Httpget(url);
  
              Httpresponse httpResponse = httpClient.ejecutar(httpGet);
              Httpentity httpEntity = httpResponse.gentileza();
              is = httpEntity.obtener el contenido();
  
          } Captura (Excepción de notificación sin soporte e) {
              e.printstacktrace();
          } Captura (Clienteprotocolexcepción e) {
              e.printstacktrace();
          } Captura (Ioexception e) {
              e.printstacktrace();
          }
  
          Tratar {
  
              Lector tamponado reader = NUEVO Lector tamponado(NUEVO Inputstreamreader(is, "iso- 8859-1"), 8);
              Constructor de cuerdas sb = NUEVO Constructor de cuerdas();
              Cuerda line = nulo;
              mientras ((line = reader.readline()) != nulo) {
                  sb.adjuntar(line + "
");
              }
              is.cerrar();
              json = sb.toString();
  
          } Captura (Excepción e) {
              Iniciar sesión.e(TAG, "Error al convertir el resultado" + e.toString());
          }
  
          Tratar {
              jObj = NUEVO jsonobject(json);
          } Captura (Jsonexception e) {
              Iniciar sesión.e(TAG, "Error al analizar datos" + e.toString());
          }
  
          Regreso jObj;
      }
    }
      

Respuesta exitosa

      
  {
    "habla a":"flowerjill@aol.com",
    "estado":"válido",
    "sub_status":"",
    "correo electrónico gratuito":Cierto,
    "querías decir":nulo,
    "cuenta":"flowerjill",
    "dominio":"aol.com",
    "domain_age_days": "8426",
    "smtp_provider":"yahoo",
    "mx_record":"mx-aol.mail.gm0.yahoodns.net",
    "mx_found": Cierto,
    "primer nombre":"jill",
    "apellido":"stein",
    "género":"hembra",
    "país":"Estados Unidos",
    "región":"Florida",
    "ciudad":"West Palm Beach",
    "código postal":"33401",
    "procesado en":"2017-04-01 02:48:02.592"
    }
      

Respuesta de error

      
      {"error":"Clave API no válida o su cuenta se quedó sin créditos"}
      // Ejemplo de respuesta de falla usando la API con cualquiera de los métodos Get
      

La API devolverá estos resultados en formato JSON utilizando el método "Validar".

Propiedades JSON

  • Propiedades
    Descripción
  • habla a
    La dirección de correo electrónico que está validando.
  • estado
    [válido, inválido, general, desconocido, spam, abuso, do_not_mail]
  • sub_status
    [antispam_system,
    greylisted, 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, desechable, tóxico]
  • cuenta
    La parte de la dirección de correo electrónico antes del símbolo "@".
  • Dominio
    La parte de la dirección de correo electrónico despus del símbolo "@".
  • querías decir
    Solución sugerente para un error tipográfico de correo electrónico
  • domain_age_days
    Antigüedad del dominio de correo electrónico en días o [nulo].
  • correo electrónico gratuito
    [verdadero / falso] Si el correo electrónico proviene de un proveedor gratuito.
  • mx_found
    [verdadero / falso] ¿El dominio tiene un registro MX?
  • mx_record
    El registro MX preferido del dominio.
  • smtp_provider
    El proveedor SMTP del correo electrónico o [nulo] [BETA].
  • nombre de pila
    El primer nombre del propietario del correo electrónico cuando esté disponible o [nulo].
  • apellido
    El apellido del propietario del correo electrónico cuando esté disponible o [nulo].
  • género
    El género del propietario del correo electrónico cuando está disponible o [nulo].
  • ciudad
    La ciudad de la IP pasó.
  • región
    La región / estado de la IP pasada.
  • código postal
    El código postal de la IP pasado.
  • país
    El país de la IP pasó.
  • procesado en
    La hora UTC en que se validó el correo electrónico.