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

// 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;
      }
    }