Obtener saldo de crédito (v2)

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

    Tratar {
      Cuerda 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;
      }
  }