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

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

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

$ curl = curl_init();

curl_setopt_array($ curl, formación(
  CURLOPT_URL => "https://bulkapi.zerobounce.net/v2/sendfile",
  CURLOPT_RETURNTRANSFER => Cierto,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "ENVIAR",
  CURLOPT_POSTFIELDS => "------ WebKitFormBoundary7MA4YWxkTrZu0gW Disposición de contenido: datos de formulario; nombre ="clave api"replacewithyours ------ WebKitFormBoundary7MA4YWxkTrZu0gW Content-Disposition: form-data; name ="email_address_column"replacewithyours ------ WebKitFormBoundary7MA4YWxkTrZu0gW--",
  CURLOPT_HTTPHEADER => formación(
    "Ficha de cartero: fae6714d-dc09- 4 e08-b50d-c97030603b61",
    "control de caché: sin caché",
    "content-type: multipart / form-data; boundary = ---- WebKitFormBoundary7MA4YWxkTrZu0gW"
  ),
));

$ respuesta = curl_exec($ curl);
$ err = curl_error($ curl);

curl_close($ curl);

Si ($ err) {
  eco "Error de cURL #:" . $ err;
} más {
  eco $ respuesta;
}
?>
    

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

  Okhttpclient client = NUEVO Okhttpclient();

  Tipo de medio mediaType = Tipo de medio.analizar gramaticalmente("multipart / form-data; boundary = ---- WebKitFormBoundary7MA4YWxkTrZu0gW");
  Cuerpo de pedido body = Cuerpo de pedido.crear(mediaType, "------Webkitformboundary7ma4ywxktrzu0gw
Contenido-Disposición: form-data; name="clave api"

replacewithyours
------Webkitformboundary7ma4ywxktrzu0gw
Contenido-Disposición: form-data; name="email_address_column"

replacewithyours
------Webkitformboundary7ma4ywxktrzu0gw--");
  Solicitud request = NUEVO Solicitud.Constructor()
    .url("https://bulkapi.zerobounce.net/v2/sendfile")
    .enviar(body)
    .addheader("Tipo de contenido", "multipart / form-data; boundary = ---- WebKitFormBoundary7MA4YWxkTrZu0gW")
    .addheader("control de caché", "sin caché")
    .addheader("Ficha de cartero", "25 d608ba- 6 cb5- 4 c8c- 88 d7-d47276c67d8e")
    .construir();
  
  Respuesta response = client.nueva llamada(request).ejecutar();
    

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

  conn = http.client.HTTPConnection("bulkapi, zerobounce, net")
  
  payload = "------WebKitFormBoundary7MA4YWxkTrZu0gW
Content-Disposition: form-data; name="clave api"

replacewithyours
------WebKitFormBoundary7MA4YWxkTrZu0gW
Content-Disposition: form-data; name="email_address_column"

replacewithyours
------WebKitFormBoundary7MA4YWxkTrZu0gW--"
  
  headers = {
      'tipo de contenido': "multipart / form-data; boundary = ---- WebKitFormBoundary7MA4YWxkTrZu0gW",
      'control de caché': "sin caché",
      'Ficha de cartero': "bc455eda- 9884-417 e-b16f- 3 a5fef3f7540"
      }
  
  conn.request("ENVIAR", "v2, archivo de envío", payload, headers)
  
  res = conn.getresponse()
  data = res.read()
  
  impresión(data.decode("utf- 8"))
    
    

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

  importar Fundación

  dejar headers = [
    "Tipo de contenido": "multipart / form-data; boundary = ---- WebKitFormBoundary7MA4YWxkTrZu0gW",
    "control de caché": "sin caché",
    "Ficha de cartero": "2 f68fcc3-d9b6- 458 b-b613- 56 f6a03e6617"
  ]
  dejar parameters = [
    [
      "nombre": "clave api",
      "valor": "replacewithyours"
    ],
    [
      "nombre": "email_address_column",
      "valor": "replacewithyours"
    ]
  ]
  
  dejar boundary = "---- WebKitFormBoundary7MA4YWxkTrZu0gW"
  
  var body = ""
  var error: Nserror? = nulo
  para param en parameters {
    dejar paramName = param["nombre"]!
    body += "--(boundary)
"
    body += "Disposición de contenido: datos de formulario; nombre ="(paramName)""
    Si dejar filename = param["nombre del archivo"] {
      dejar contentType = param["Tipo de contenido"]!
      dejar fileContent = Cuerda(contentsOfFile: filename, encoding: Cuerda.Codificación.utf8)
      Si (error != nulo) {
        impresión(error)
      }
      body += "; filename ="(filename)"
"
      body += "Contenido-Tipo: (contentType)

"
      body += fileContent
    } más Si dejar paramValue = param["valor"] {
      body += "

(paramValue)"
    }
  }
  
  dejar request = Nsmutableurlrequest(url: NSURL(string: "https://bulkapi.zerobounce.net/v2/sendfile")! COMO url,
                                          cachePolicy: .useProtocolCachePolicy,
                                      timeoutInterval: 10.0)
  request.httpMethod = "ENVIAR"
  request.allHTTPHeaderFields = headers
  request.httpBody = postData COMO Datos
  
  dejar session = Sesión.shared
  dejar dataTask = session.tarea de datos(with: request COMO Solicitud de url, completionHandler: { (data, response, error) -> vacío en
    Si (error != nulo) {
      impresión(error)
    } más {
      dejar httpResponse = response COMO? Httpurlresponse
      impresión(httpResponse)
    }
  })
  
  dataTask.currículum()
    

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


// Seleccione el idioma VB o C # para enviar el archivo de muestra # importar  <Foundation/Foundation.h>

NSDictionary *headers = @{ @"tipo de contenido": @ "multipart / form-data; boundary = ---- WebKitFormBoundary7MA4YWxkTrZu0gW",
                            @ "control de caché": @ "sin caché",
                            @ "Cartero-Token": @ "92 c5b06e- 624 f- 44 e5-bd86-f537bc6cef67" };
NSArray *parameters = @[ @{ @"nombre": @"clave api", @"valor": @ "replacewithyours" },
                          @{ @"nombre": @ "email_address_column", @"valor": @ "replacewithyours" } ];
NSString *boundary = @ "---- WebKitFormBoundary7MA4YWxkTrZu0gW";

NSError *error;
NSMutableString *body = [NSMutableString string];
para (NSDictionary *param en parameters) {
    [body appendFormat:@"--%@
", boundary];
    Si (param[@"nombre del archivo"]) {
        [body appendFormat:@ "Disposición de contenido: datos de formulario; nombre ="%@ "; filename ="%@"
", param [@"name"], parámetro [@"fileName"]];
        [body appendFormat:@"Content-Type: %@

", param [@"contentType"]];
        [body appendFormat:@"%@", [NSString stringWithContentsOfFile:param[@"nombre del archivo"] encoding:NSUTF8StringEncoding error:&error]];
        Si (error) {
            Nslog(@"%@", error);
        }
    } más {
        [body appendFormat:@ "Disposición de contenido: datos de formulario; nombre ="%@"

", param [@"name"]];
        [body appendFormat:@"%@", param[@"valor"]];
    }
}
[body appendFormat:@"
--%@--
", boundary];
NSData *postData = [body dataUsingEncoding:NSUTF8StringEncoding];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"https://bulkapi.zerobounce.net/v2/sendfile"]
                                                        cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                    timeoutInterval:10.0];
[request setHTTPMethod:@"ENVIAR"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                Si (error) {
                                                    Nslog(@"%@", error);
                                                } más {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    Nslog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];
    

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

//N/A