Obtener saldo de crédito (v1)

Esta API le dirá cuántos créditos le quedan en su cuenta. Es simple, rápido y fácil de usar.

Aquí hay algunos escenarios para los que las empresas utilizarán esta API.

  • Utiliza nuestra API para validar correos electrónicos y debe verificar dentro de un cierto período de tiempo cuando su saldo de crédito es demasiado bajo, para que pueda realizar un pago.
  • Desea realizar un seguimiento de la cantidad de créditos de validación de correo electrónico que está utilizando según su marco de tiempo definido para generar información estadística útil.
  • Desea automatizar e integrar información en el tablero de su aplicación que le muestra su saldo de crédito restante actual.
  • A continuación, encontrará las instrucciones sobre cómo usar nuestra API. Es muy fácil de usar y requiere SSL.

Esta API le dirá cuántos créditos le quedan en su cuenta.

GET / v1 / getcredits

URL de API: https://bulkapi.zerobounce.net/v1/getcredits

Parámetros URL

  • Parámetro
    Descripción
  • apikey
    Su clave API, que se encuentra en su cuenta.

Si desea llamar a la API desde su navegador para probarla, todo lo que tiene que hacer es reemplazar la CLAVE API con su clave:

https://api.zerobounce.net/v1/getcredits?apikey=[replacewithyours]

Esta API le dirá cuántos créditos le quedan en su cuenta.

La API devolverá estos resultados en formato JSON utilizando el método "getcredits". Créditos: la cantidad de créditos que le quedan en su cuenta para las validaciones de correo electrónico. Si se devuelve un - 1, eso significa que su clave API no es válida.

Obtener ejemplos de código API de créditos

  • Visual básico
  • C#
  • PHP
  • Java
  • Pitón
  • Rápido
  • C objetivo
  • Android java
      
'Las bibliotecas y envoltorios API completos se pueden encontrar aquí: 
' https://www.zerobounce.net/docs/zerobounce-api-wrappers/#api_wrappers__v2__dot_net

  Tratar
  Oscuro apiKey = "Tu llave secreta"
  Oscuro apiURL = "https://api.zerobounce.net/v1/getcredits?apikey=" & apiKey

  Oscuro request COMO HttpWebRequest = Difusión directa(WebRequest.Create(apiURL), HttpWebRequest)
  request.Se acabó el tiempo = 150000
  request.Method = "OBTENER"

  Utilizando response COMO WebResponse = request.GetResponse()
      response.GetResponseStream().ReadTimeout = 20000
      Utilizando ostream COMO NUEVO StreamReader(response.GetResponseStream())
          responseString = ostream.ReadToEnd()
      Fin Utilizando
  Fin Utilizando
Captura ex COMO exception
'Excepción de captura: todos los errores se mostrarán aquí, si hay problemas con la API
Fin Tratar
    

    // 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/v1/getcredits?apikey=" + 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) {
      /Captura Exception - Todos errors will be shown here - Si there are issues with the 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/v1/getcredits?apikey='.$ 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/v1/getcredits?apikey="+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/v1/getcredits?apikey="
    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/v1/getcredits?apikey=%@", 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()
    


  // 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 *urlString = [NSString stringWithFormat:@"https://api.zerobounce.net/v1/getcredits?apikey=%@", 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 construir.gradle (Aplicación) in the "androide" bracket:
  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/v1/getcredits?apikey="+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;
      }
  }
    

Respuesta de punto final

Respuesta exitosa

      
    {"Créditos":2375323}
    

Respuesta de error

      
    {"Créditos":-1}