Inicio rápido de API

    // 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 apiURL = "https://api.zerobounce.net/v2/getcredits?api_key=" + apiKey; 
    
      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';
    // usa curl para hacer la solicitud
    $ url = 'https://api.zerobounce.net/v2/getcredits?api_key='.$ apiKey;
    
    $ ch = curl_init($ url);
    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 targetURL = "https://api.zerobounce.net/v2/getcredits?api_key="+key;

        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
    
importar requests
importar json

target_url = "https://api.zerobounce.net/v2/getcredits?api_key="
secret_key = "Tu llave secreta"

api_response = requests.get("%s%s" % (target_url, secret_key))
data = json.loads(api_response.content)

# imprime el número de créditos
impresión data["Créditos"]

    

    // 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 url = url(string: Cuerda(format: "https://api.zerobounce.net/v2/getcredits?api_key=%@", key))
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()
    

  NSString *key = @ "Tu clave secreta";
  NSString *urlString = [NSString stringWithFormat:@"https://api.zerobounce.net/v2/getcredits?api_key=%@", key];
  
  __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 url = "https://api.zerobounce.net/v2/getcredits?api_key="+key;

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

// 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 start_date = "2018-01-01";
  Cuerda end_date = "2019-12-12";
  
  Cuerda responseString = "";
  
  Cuerda apiURL = "https://api.zerobounce.net/v2/getapiusage?api_key=" + api_key + "& start_date =" +  start_date + "& end_date =" + end_date;
  
  
      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';
  $ start_date = '2018-01-01';
  $ end_date = '2019-12-12';
  // usa curl para hacer la solicitud
  $ url = 'https://api.zerobounce.net/v2/getapiusage?api_key='.$ api_key.'& start_date ='.$ start_date.'& end_date ='.$ end_date;
  
  $ 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 start_date = "2018-01-01";
        Cuerda end_date = "2019-12-12"; 
        Cuerda targetURL = "https://api.zerobounce.net/v2/getapiusage?api_key="+key+"& start_date ="+start_date+"& end_date ="+end_date;


        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/getapiusage"
  api_key = "Tu llave secreta"
  start_date = "2018-01-01" 
  end_date = "2019-12-12"
  
  
  params = {"clave api": api_key, "fecha de inicio": start_date, "fecha final":end_date}
  
  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 start_date = "2018-01-01"
dejar end_date = "2019-12-12" // la dirección ip puede estar en blanco
dejar url = url(string: Cuerda(format: "https://api.zerobounce.net/v2/getapiusage?api_key=%@&start_date=%@&end_date=%@", key, start_date, end_date))
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 *start_date = @"2018-01-01";
  NSString *end_date = @"2019-12-12"; 
  
  NSString *urlString = [NSString stringWithFormat:@"https://api.zerobounce.net/v2/getapiusage?api_key=%@&start_date=%@&end_date=%@", key, start_date, end_date];
  
  __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 start_date = "2018-01-01";
      Cuerda end_date = "2019-12-12";
      Cuerda url = "https://api.zerobounce.net/v2/getapiusage?api_key="+key+"& start_date ="+start_date+"& end_date ="+end_date;
  
      @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;
      }
  }
    

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

    var apiURL = "https://bulkapi.zerobounce.net/v2/validatebatch";
    var apiKey = "Su clave API";

    var formData = "{"api_key":"" + apiKey + "", " +
        ""email_batch":[" +
        "{"email_address": "valid@example.com","ip_address": "1.1.1.1"}," +
        "{"email_address": "invalid@example.com","ip_address": "1.1.1.1"}," +
        "{"email_address": "disposable@example.com","ip_address": null}]}";

    Httpwebrequest request = (HttpWebRequest)WebRequest.crear(apiURL);
    request.Method = "ENVIAR";
    request.ContentType = "application/json";
    request.ContentLength = formData.Length;

    byte[] formLookupDataBytes = UTF8Encoding.UTF8.GetBytes(formData);

    Utilizando (Corriente postStream = request.GetRequestStream())
    {
        postStream.Escribir(formLookupDataBytes, 0, formLookupDataBytes.Length);
    }

    Utilizando (var response = (HttpWebResponse)request.Obtener una respuesta())
    {
        Utilizando (var sr = NUEVO Lector de corriente(response.Getresponsestream()))
        {
            var responseString = sr.Readtoend();
        }
    }
        

<?php

$ curl = curl_init();
curl_setopt_array($ curl, formación(
  CURLOPT_URL => "https://bulkapi.zerobounce.net/v2/validatebatch",
  CURLOPT_RETURNTRANSFER => Cierto,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 0,
  CURLOPT_FOLLOWLOCATION => Cierto,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "ENVIAR",
  CURLOPT_POSTFIELDS =>"{"clave api":"Your API KEY", "email_batch":[{"email_address": "valid@example.com","dirección ip": "1.1.1.1"},{"email_address": "invalid@example.com","dirección ip": "1.1.1.1"},{"email_address": "disposable@example.com","dirección ip": null}]}",
  CURLOPT_HTTPHEADER => formación(
    "x-token: eyJ0eXAiOiJKV1QiLCJhbGciOiJIUzI1NiJ9.eyJ1c2VybmFtZSI6ImhlbnJ5QHplcm9ib3VuY2UubmV0IiwiZXhwIjoxNTk1NzEzNTI1fQ.nzOT-bJ8_tvnrNy3t1DeIDNMXxS-YEvlCbZye-9vpr4",
    "Content-Type: application/json",
    "Cookie: __cfduid=db977bdba3d06a8c9c19b45a92d6221b41572452483"
  ),
));

$ respuesta = curl_exec($ curl);

curl_close($ curl);
eco $ respuesta;
?>
      
        

    importar http.client
    importar mimetypes
    conn = http.client.HTTPSConnection("bulkapi.zerobounce.net")
    payload = '{
      "clave api":"Su clave API",
      "email_batch":[
          {
            "email_address": "valid@example.com",
            "dirección ip": "1.1.1.1"
          },
          {
            "email_address": "invalid@example.com",
            "dirección ip": "1.1.1.1"
          },
          {
            "email_address": "disposable@example.com",
            "dirección ip": null
          }
        ]
    }'
    headers = {
      'x-token': 'eyJ0eXAiOiJKV1QiLCJhbGciOiJIUzI1NiJ9.eyJ1c2VybmFtZSI6ImhlbnJ5QHplcm9ib3VuY2UubmV0IiwiZXhwIjoxNTk1NzEzNTI1fQ.nzOT-bJ8_tvnrNy3t1DeIDNMXxS-YEvlCbZye-9vpr4',
      'tipo de contenido': 'application/json',
      'Cookie': '__cfduid=db977bdba3d06a8c9c19b45a92d6221b41572452483'
    }
    conn.request("ENVIAR", "/v2/validatebatch", payload, headers)
    res = conn.getresponse()
    data = res.read()
    impresión(data.decode("utf- 8"))
        

     
    importar Fundación

    var semaphore = DispatchSemaphore (value: 0)
    
    dejar parameters = "{"api_key":"Your API KEY", "email_batch":[{"email_address": "valid@example.com","ip_address": "1.1.1.1"},{"email_address": "invalid@example.com","ip_address": "1.1.1.1"},{"email_address": "disposable@example.com","ip_address": null}]}"
    dejar postData = parameters.Datos(using: .utf8)
    
    var request = Solicitud de url(url: url(string: "https://bulkapi.zerobounce.net/v2/validatebatch")!,timeoutInterval: Double.infinity)
    request.addValue("eyJ0eXAiOiJKV1QiLCJhbGciOiJIUzI1NiJ9.eyJ1c2VybmFtZSI6ImhlbnJ5QHplcm9ib3VuY2UubmV0IiwiZXhwIjoxNTk1NzEzNTI1fQ.nzOT-bJ8_tvnrNy3t1DeIDNMXxS-YEvlCbZye-9vpr4", forHTTPHeaderField: "x-token")
    request.addValue("application/json", forHTTPHeaderField: "Tipo de contenido")
    request.addValue("__cfduid=db977bdba3d06a8c9c19b45a92d6221b41572452483", forHTTPHeaderField: "Cookie")
    
    request.httpMethod = "ENVIAR"
    request.httpBody = postData
    
    dejar task = Sesión.shared.tarea de datos(with: request) { data, response, error en 
      guard dejar data = data más {
        impresión(Cuerda(describing: error))
        Regreso
      }
      impresión(Cuerda(data: data, encoding: .utf8)!)
      semaphore.signal()
    }
    
    task.currículum()
    semaphore.wait()   
        

curl --location --request POST 'https://bulkapi.zerobounce.net/v2/validatebatch' --header 'x-token: eyJ0eXAiOiJKV1QiLCJhbGciOiJIUzI1NiJ9.eyJ1c2VybmFtZSI6ImhlbnJ5QHplcm9ib3VuY2UubmV0IiwiZXhwIjoxNTk1NzEzNTI1fQ.nzOT-bJ8_tvnrNy3t1DeIDNMXxS-YEvlCbZye-9vpr4' --header 'Content-Type: application/json' --header 'Cookie: __cfduid=db977bdba3d06a8c9c19b45a92d6221b41572452483' --data-raw '{"api_key":"Your API KEY",
 "email_batch":[
{"email_address": "valid@example.com","ip_address": "1.1.1.1"},
{"email_address": "invalid@example.com","ip_address": "1.1.1.1"},
{"email_address": "disposable@example.com","ip_address": null}
]
}'
        

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

// Enviar muestra de archivo en C #

Público Clase Sendfilestatus
{
    Público bool success { obtener; conjunto; }
    Público Cuerda message { obtener; conjunto; }
    Público Cuerda file_name { obtener; conjunto; }
    Público Cuerda file_id { obtener; conjunto; }
}

Privado estático vacío Sendfileapitest()
{
    Cuerda fileFullPath = $"ruta de archivo completa de un archivo csv o txt";  //necesario
    Cuerda apiKey = "reemplace con su clave de api aquí";  //necesario       
    en t emailAddressColumn = 2;  //necesario
    en t? firstNameColumn = 5;  //Opcional
    en t? lastNameColumn = 6;  //Opcional
    en t? genderColumn = nulo;  //Opcional
    en t? ipAddressColumn = 11;  //Opcional
    bool? hasHeaderRow = Cierto;  //Opcional
    Cuerda returnUrl = nulo;  //Opcional

    Tratar
    {
        Sendfilestatus sendFileStatus = Enviar archivo(fileFullPath, apiKey, emailAddressColumn, firstNameColumn, lastNameColumn, genderColumn, ipAddressColumn, hasHeaderRow, returnUrl).Result;
        Console.Escribir(JsonConvert.Serializeobject(sendFileStatus, Formatting.Indented));
    }
    Captura (Excepción ex)
    {
        Console.Escribir(ex.InnerException.Message);
    }

    Console.Leer la clave();

}

Público estático asíncrono Task<SendFileStatus> Enviar archivo(Cuerda fileFullPath, Cuerda apiKey, en t emailAddressColumn, 
    en t? firstNameColumn = nulo, en t? lastNameColumn = nulo, en t? genderColumn = nulo, 
    en t? ipAddressColumn = nulo, bool? hasHeaderRow = nulo, Cuerda returnUrl = nulo)
{
    Si (Cuerda.Isnullorempty(fileFullPath))
        Lanzar NUEVO Excepción("Error: se requiere fileFullPath");
    Si (Cuerda.Isnullorempty(apiKey))
        Lanzar NUEVO Excepción("Error: se requiere apiKey");

    var fi = NUEVO Información del archivo(fileFullPath);
    var fileContents = File.Readallbytes(fi.FullName);
    var fileName = fi.Name;

    Uri uri = NUEVO Uri(@"https://bulkapi.zerobounce.net/v2/sendfile");

    Utilizando (var client = NUEVO Httpclient())
    Utilizando (var request = NUEVO Httprequestmessage(HttpMethod.Post, uri))
    {
        Contenido de datos de varias partes multiPartContent = NUEVO Contenido de datos de varias partes();
        Bytearraycontent byteArrayContent = NUEVO Bytearraycontent(fileContents);
        byteArrayContent.Headers.Añadir("Tipo de contenido", "texto / csv");
        multiPartContent.Añadir(byteArrayContent, "expediente", fileName);
        multiPartContent.Añadir(NUEVO Cadena de contenido(apiKey), "clave api");
        multiPartContent.Añadir(NUEVO Cadena de contenido(emailAddressColumn.ToString()), "email_address_column");
        Si (firstNameColumn != nulo)
            multiPartContent.Añadir(NUEVO Cadena de contenido(firstNameColumn.ToString()), "nombre_columna_nombre");
        Si (lastNameColumn != nulo)
            multiPartContent.Añadir(NUEVO Cadena de contenido(lastNameColumn.ToString()), "apellido_columna");
        Si (genderColumn != nulo)
            multiPartContent.Añadir(NUEVO Cadena de contenido(genderColumn.ToString()), "género_columna");
        Si (ipAddressColumn != nulo)
            multiPartContent.Añadir(NUEVO Cadena de contenido(ipAddressColumn.ToString()), "ip_address_column");
        Si (hasHeaderRow != nulo)
            multiPartContent.Añadir(NUEVO Cadena de contenido((hasHeaderRow == Cierto) ? "cierto" : "falso"), "has_header_row");
        Si (returnUrl != nulo)
            multiPartContent.Añadir(NUEVO Cadena de contenido(returnUrl.ToString()), "return_url");

        request.Content = multiPartContent;

        Utilizando (var response = esperar client.Sendasync(request, HttpCompletionOption.ResponseContentRead, CancellationToken.None).Configureawait(Falso))
        {
            var content = esperar response.Content.Readasstringasync();

            Si (response.IsSuccessStatusCode == Falso)
            {
                var error = $"StatusCode = {(int) response.StatusCode}, Content = {content}";
                Lanzar NUEVO Excepción(error);
            }

            Regreso JsonConvert.DeserializarObjeto<Sendfilestatus>(content);
        }
    }
}