Validar correos electrónicos (v1)

    // 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 apiKey = "Tu llave secreta";
      Cuerda emailToValidate = "example@example.com";
      Cuerda responseString = "";
          Cuerda apiURL = "https://api.zerobounce.net/v1/validate?apikey=" + apiKey + "& email =" +  HttpUtility.Urlencode(emailToValidate);
      
              // Descomente para usar la API opcional con búsqueda de IP
              // string apiURL = "https://api.zerobounce.net/v1/validatewithip?apikey=" + apiKey +" & email = "+ HttpUility.UrlEncode (emailToValidate); +" & ipaddress = "+ HttpUtility.UrlEncode (" 99.123.12.122 ")
      
          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
    $ apiKey = 'Tu clave secreta';
    $ emailToValidate = 'example@example.com';
    $ IPToValidate = '99.123.12.122';
    // usa curl para hacer la solicitud
    $ url = 'https://api.zerobounce.net/v1/validate?apikey='.$ apiKey.'& email ='.Urlencode($ emailToValidate);
    // Descomente para usar la API opcional con búsqueda de IP
    // $ url = 'https://api.zerobounce.net/v1/validatewithip?apikey='.$apiKey.'&email='.urlencode($emailToValidate).'&ipaddress='.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";
            Cuerda targetURL = "https://api.zerobounce.net/v1/validate?apikey="+key+"& email ="+email;
    // Descomente para usar la API opcional con búsqueda de IP
    // String targetURL = "https://api.zerobounce.net/v1/validatewithip?apikey="+key+"&email="+email+"&ipaddress="+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/v1/validate"
    apikey = "Tu llave secreta"
    email = "example@example.com"
    ipaddress = "99.123.12.122"
    
    params = {"correo electrónico": email, "clave api": apikey}
    
    # Descomentar para usar la API opcional con búsqueda de IP
    # params ["ipaddress"] = ipaddress
    
    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 url = url(string: Cuerda(format: "https://api.zerobounce.net/v1/validate?apikey=%@&email=%@", key, email))
    dejar ip = "99.123.12.122"
    // Descomente para usar la API opcional con búsqueda de IP
    // let url = URL (string: String (formato: "https://api.zerobounce.net/v1/validatewithip?apikey=%@&email=%@&ipaddress=%@", clave, correo electrónico, 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";
    NSString *urlString = [NSString stringWithFormat:@"https://api.zerobounce.net/v1/validate?apikey=%@&email=%@", key, email];
    // NSString * urlString = [NSString stringWithFormat: @ "https://api.zerobounce.net/v1/validatewithip?apikey=%@&email=%@&ipaddress=%@", clave, correo electrónico, ip];
    // Descomente para usar la API opcional con búsqueda de 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";
        Cuerda url = "https://api.zerobounce.net/v1/validate?apikey="+key+"& email ="+email;
    // Descomente para usar la API opcional con búsqueda de IP
    // URL de cadena = "https://api.zerobounce.net/v1/validatewithip?apikey="+key+"&email="+email+"&ipaddress="+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;
        }
    }