Inicio rápido de API

Versión 2: Comenzando

/ email-validation-api-quickstart / v2-getting-start /

Colección Cartero

Para probar la versión 2 de la API en Cartero , guarde el contenido de la Colección Postman como un archivo .json o puede obtener el archivo de nuestro GitHub repositorio.

En Cartero, en el menú superior, haga clic en Archivo, luego elija Importar. Luego, elija el archivo JSON que guardó o descargó de GitHub para importarlo.

Archivo JSON de la colección Postman:

{
  "información": {
    "_postman_id": "948780 e4-bf36- 4 c9c-bb29- 2 c32c9053091",
    "nombre": "zerobounce api v2",
    "esquema": "https://schema.getpostman.com/json/collection/v2.0.0/collection.json"
  },
  "articulo": [
    {
      "nombre": "Validar correos electrónicos",
      "solicitud": {
        "método": "OBTENER",
        "encabezamiento": [],
        "cuerpo": {
          "modo": "crudo",
          "crudo": ""
        },
        "url": {
          "crudo": "https://api.zerobounce.net/v2/validate?api_key=replacewithyours&email=replacewithyours&ip_address=",
          "protocolo": "https",
          "anfitrión": [
            "api",
            "rebote cero",
            "red"
          ],
          "camino": [
            "v2",
            "validar"
          ],
          "consulta": [
            {
              "llave": "clave api",
              "valor": "replacewithyours",
              "descripción": "Su clave API, que se encuentra en su cuenta".
            },
            {
              "llave": "correo electrónico",
              "valor": "replacewithyours",
              "descripción": "La dirección de correo electrónico que desea validar"
            },
            {
              "llave": "dirección ip",
              "valor": "",
              "descripción": "La dirección IP desde la que se registró el correo electrónico (puede estar en blanco, pero se requiere un parámetro)"
            }
          ]
        },
        "descripción": "API para validación de una sola dirección de correo electrónico".
      },
      "respuesta": []
    },
    {
      "nombre": "Obtener saldo de crédito",
      "solicitud": {
        "método": "OBTENER",
        "encabezamiento": [],
        "cuerpo": {
          "modo": "crudo",
          "crudo": ""
        },
        "url": {
          "crudo": "https://api.zerobounce.net/v2/getcredits?api_key=replacewithyours",
          "protocolo": "https",
          "anfitrión": [
            "api",
            "rebote cero",
            "red"
          ],
          "camino": [
            "v2",
            "obtener créditos"
          ],
          "consulta": [
            {
              "llave": "clave api",
              "valor": "replacewithyours",
              "descripción": "Su clave API, que se encuentra en su cuenta".
            }
          ]
        },
        "descripción": "Esta API le dirá cuántos créditos le quedan en su cuenta".
      },
      "respuesta": []
    },
    {
      "nombre": "Enviar archivo",
      "solicitud": {
        "método": "ENVIAR",
        "encabezamiento": [],
        "cuerpo": {
          "modo": "formdata",
          "formdata": [
            {
              "llave": "expediente",
              "descripción": "archivo csv o txt",
              "tipo": "expediente",
              "src": ""
            },
            {
              "llave": "clave api",
              "valor": "replacewithyours",
              "descripción": "Su clave API, encontrada en su cuenta. (Obligatorio)",
              "tipo": "texto"
            },
            {
              "llave": "return_url",
              "valor": "",
              "descripción": "La URL se utilizará para devolver la llamada cuando se complete la validación. (Opcional)",
              "tipo": "texto",
              "discapacitado": Cierto
            },
            {
              "llave": "email_address_column",
              "valor": "replacewithyours",
              "descripción": "El índice de la columna de la dirección de correo electrónico en su archivo. El índice comienza desde 1. (Obligatorio, número)",
              "tipo": "texto"
            },
            {
              "llave": "nombre_columna_nombre",
              "valor": "",
              "descripción": "El índice de columna de la columna de nombre. (Opcional, número)",
              "tipo": "texto",
              "discapacitado": Cierto
            },
            {
              "llave": "apellido_columna",
              "valor": "",
              "descripción": "El índice de columna de la columna de apellido. (Opcional, número)",
              "tipo": "texto",
              "discapacitado": Cierto
            },
            {
              "llave": "género_columna",
              "valor": "",
              "descripción": "El índice de columna de la columna de género. (Opcional, número)",
              "tipo": "texto",
              "discapacitado": Cierto
            },
            {
              "llave": "ip_address_column",
              "valor": "",
              "descripción": "La dirección IP desde la que se registró el correo electrónico. (Opcional, número)",
              "tipo": "texto",
              "discapacitado": Cierto
            },
            {
              "llave": "has_header_row",
              "valor": "",
              "descripción": "Si la primera fila del archivo enviado es una fila de encabezado. (Opcional, verdadero / falso)",
              "tipo": "texto",
              "discapacitado": Cierto
            }
          ]
        },
        "url": "https://bulkapi.zerobounce.net/v2/sendfile",
        "descripción": "Esta API permite al usuario enviar un archivo para la validación masiva de correo electrónico".
      },
      "respuesta": []
    },
    {
      "nombre": "Estado del archivo",
      "solicitud": {
        "método": "OBTENER",
        "encabezamiento": [],
        "cuerpo": {
          "modo": "crudo",
          "crudo": ""
        },
        "url": {
          "crudo": "https://bulkapi.zerobounce.net/v2/filestatus?api_key=replacewithyours&file_id=replacewithyours",
          "protocolo": "https",
          "anfitrión": [
            "bulkapi",
            "rebote cero",
            "red"
          ],
          "camino": [
            "v2",
            "estado de los archivos"
          ],
          "consulta": [
            {
              "llave": "clave api",
              "valor": "replacewithyours",
              "descripción": "Su clave API, que se encuentra en su cuenta".
            },
            {
              "llave": "file_id",
              "valor": "replacewithyours",
              "descripción": "El ID de archivo devuelto cuando se llama a la API sendfile".
            }
          ]
        },
        "descripción": "La API devuelve el estado de procesamiento del archivo enviado con la API sendfile".
      },
      "respuesta": []
    },
    {
      "nombre": "Obtener el archivo",
      "solicitud": {
        "método": "OBTENER",
        "encabezamiento": [],
        "cuerpo": {
          "modo": "crudo",
          "crudo": ""
        },
        "url": {
          "crudo": "https://bulkapi.zerobounce.net/v2/getfile?api_key=replacewithyours&file_id=replacewithyours",
          "protocolo": "https",
          "anfitrión": [
            "bulkapi",
            "rebote cero",
            "red"
          ],
          "camino": [
            "v2",
            "obtener el archivo"
          ],
          "consulta": [
            {
              "llave": "clave api",
              "valor": "replacewithyours",
              "descripción": "Su clave API, que se encuentra en su cuenta".
            },
            {
              "llave": "file_id",
              "valor": "replacewithyours",
              "descripción": "El ID de archivo devuelto cuando se llama a la API sendfile".
            }
          ]
        },
        "descripción": "La API permite a los usuarios obtener el archivo de resultados de validación para el archivo enviado mediante la API sendfile".
      },
      "respuesta": []
    },
    {
      "nombre": "Borrar archivo",
      "solicitud": {
        "método": "OBTENER",
        "encabezamiento": [],
        "cuerpo": {
          "modo": "crudo",
          "crudo": ""
        },
        "url": {
          "crudo": "https://bulkapi.zerobounce.net/v2/deletefile?api_key=replacewithyours&file_id=replacewithyours",
          "protocolo": "https",
          "anfitrión": [
            "bulkapi",
            "rebote cero",
            "red"
          ],
          "camino": [
            "v2",
            "borrar archivo"
          ],
          "consulta": [
            {
              "llave": "clave api",
              "valor": "replacewithyours",
              "descripción": "Su clave API, que se encuentra en su cuenta".
            },
            {
              "llave": "file_id",
              "valor": "replacewithyours",
              "descripción": "El ID de archivo devuelto cuando se llama a la API sendfile".
            }
          ]
        },
        "descripción": "La API devuelve el estado de procesamiento del archivo enviado con la API sendfile".
      },
      "respuesta": []
    }
  ]
}

Obtener saldo de crédito (v2)

/ email-validation-api-quickstart / v2-credit-balance /

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.

GET / v2 / getcredits

URL de API: https://api.zerobounce.net/v2/getcredits

A continuación encontrará las instrucciones sobre cómo usar nuestra API, es muy fácil de usar y requiere SSL. La API requiere que tenga un saldo de crédito activo y nunca consumirá un crédito por ningún resultado desconocido.

Parámetros URL

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

Obtener muestras de código de saldo de crédito

  • 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/v2/getcredits?api_key=" & 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/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;
      }
  }
    

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

If you want to call the API from your browser to test it, all you have to do is to replace the API KEY with your key:

https://api.zerobounce.net/v2/getcredits?api_key=[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.

Respuesta de punto final

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

Respuesta exitosa

      
  {"Créditos":2375323}
    

Respuesta de error

      
  {"Créditos":-1}
    

Obtener uso de API (v2)

/ email-validation-api-quickstart / v2-get-api-use /

GET / v2 / getapiusage

URL de API: https://bulkapi.zerobounce.net/v2/getapiusage

Parámetros URL

  • Parámetro
    Descripción
  • clave api
    Su clave API, que se encuentra en su cuenta.
  • fecha de inicio
    La fecha de inicio de cuándo desea ver el uso de la API
  • fecha final
    La fecha de finalización de cuándo desea ver el uso de la API

https://api.zerobounce.net/v2/getapiusage?%3Cyour%20key%3E&start_date=2018-01-01&end_date=2019-12-12

La API devolverá estos resultados en formato JSON utilizando el método "getapiusage".

La API devolverá estos resultados en formato JSON utilizando el método "getapiusage".

  • Parámetro
    Descripción
  • Total
    Número total de veces que se ha llamado a la API
  • ESTADO_VÁLIDO
    Total de direcciones de correo electrónico válidas devueltas por la API
  • ESTADO_INVÁLIDO
    Total de direcciones de correo electrónico no válidas devueltas por la API
  • STATUS_CATCH_ALL
    Total de direcciones de correo electrónico generales devueltas por la API
  • STATUS_DO_NOT_MAIL
    Total de direcciones de correo electrónico no enviadas por la API
  • STATUS_SPAMTRAP
    Total de direcciones de correo electrónico de spam devueltas por la API
  • ESTADO DESCONOCIDO
    Total de direcciones de correo electrónico desconocidas devueltas por la API
  • sub_status_toxic
    Número total de veces que la API tiene un estado secundario de "tóxico"
  • sub_status_disposable
    Número total de veces que la API tiene un estado secundario de "desechable"
  • sub_status_role_based
    Número total de veces que la API tiene un sub estado de "role_based"
  • sub_status_possible_trap
    Número total de veces que la API tiene un estado secundario de "posible_trap"
  • sub_status_global_suppression
    Número total de veces que la API tiene un estado secundario de "global_suppression"
  • sub_status_timeout_exceeded
    Número total de veces que la API tiene un estado secundario de "timeout_exceeded"
  • sub_status_mail_server_temporary_error
    Número total de veces que la API tiene un subestado de "mail_server_temporary_error"
  • sub_status_mail_server_did_not_respond
    Número total de veces que la API tiene un estado secundario de "mail_server_did_not_respond"
  • sub_status_greylisted
    Número total de veces que la API tiene un estado secundario de "lista gris"
  • sub_status_antispam_system
    Número total de veces que la API tiene un estado secundario de "antispam_system"
  • sub_status_does_not_accept_mail
    Número total de veces que la API tiene un estado secundario de "does_not_accept_mail"
  • sub_status_exception_occurred
    Número total de veces que la API tiene un estado secundario de "excepción_currida"
  • sub_status_failed_syntax_check
    Número total de veces que la API tiene un estado secundario de "failure_syntax_check"
  • sub_status_mailbox_not_found
    Número total de veces que la API tiene un estado secundario de "buzón_no_encontrado"
  • sub_status_unroutable_ip_address
    Número total de veces que la API tiene un estado secundario de "unroutable_ip_address"
  • sub_status_possible_typo
    Número total de veces que la API tiene un estado secundario de "possible_typo"
  • sub_status_no_dns_entries
    Número total de veces que la API tiene un estado secundario de "no_dns_entries"
  • sub_status_role_based_catch_all
    Total basado en roles para capturar todos, la API tiene un estado secundario de "role_based_catch_all"
  • sub_status_mailbox_quota_exceeded
    Número total de veces que la API tiene un estado secundario de "buzón_cuota_excedida"
  • sub_status_forcible_disconnect
    Total de desconexiones forzadas, la API tiene un estado secundario de "forcible_disconnect"
  • sub_status_failed_smtp_connection
    Total de conexiones SMTP fallidas, la API tiene un estado secundario de "failure_smtp_connection"
  • fecha de inicio
    Fecha de inicio de consulta
  • fecha final
    Fecha final de consulta

Obtenga ejemplos de código de uso de API

  • 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 api_key COMO Cuerda = "Tu llave secreta"
  Oscuro start_date COMO Cuerda = "2018-01-01"
  Oscuro end_date  COMO Cuerda = "2019-12-12" 
  Oscuro responseString COMO Cuerda = ""

Oscuro apiURL COMO Cuerda = "https://api.zerobounce.net/v2/getapiusage?api_key=" & api_key & "& start_date =" &  start_date & "& end_date =" & end_date

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

Respuesta de punto final

Respuesta exitosa

      
    {
      "total": 3,
      "status_valid": 1,
      "status_invalid": 2,
      "status_catch_all": 0,
      "status_do_not_mail": 0,
      "status_spamtrap": 0,
      "estado desconocido": 0,
      "sub_status_toxic": 0,
      "sub_status_disposable": 0,
      "sub_status_role_based": 0,
      "sub_status_possible_trap": 0,
      "sub_status_global_suppression": 0,
      "sub_status_timeout_exceeded": 0,
      "sub_status_mail_server_temporary_error": 0,
      "sub_status_mail_server_did_not_respond": 0,
      "sub_status_greylisted": 0,
      "sub_status_antispam_system": 0,
      "sub_status_does_not_accept_mail": 0,
      "sub_status_exception_occurred": 0,
      "sub_status_failed_syntax_check": 0,
      "sub_status_mailbox_not_found": 2,
      "sub_status_unroutable_ip_address": 0,
      "sub_status_possible_typo": 0,
      "sub_status_no_dns_entries": 0,
      "sub_status_role_based_catch_all": 0,
      "sub_status_mailbox_quota_exceeded": 0,
      "sub_status_forcible_disconnect": 0,
      "sub_status_failed_smtp_connection": 0,
      "fecha de inicio": "1/1/2018",
      "fecha final": "12/12/2019"
    }
    

Respuesta de error - Clave API

      
    {"error":"Clave API no válida"}
    

Respuesta de error - Fecha

      
    {"error":"Fecha invalida"}

    

Validador único de correo electrónico: en tiempo real (v2)

/ email-validation-api-quickstart / v2-validate-emails /

A continuación encontrará las instrucciones sobre cómo usar nuestra API, es muy fácil de usar y requiere SSL. La API requiere que tenga un saldo de crédito activo y nunca consumirá un crédito por ningún resultado desconocido.

Para probar o API sin usar créditos: utilice los correos electrónicos proporcionados en nuestro Modo Sandbox (v2)

El tiempo de respuesta para nuestra API es de entre un segundo y 70 segundos. Dado que las API están destinadas a ser rápidas por naturaleza, limitamos la cantidad de tiempo que pasamos validando una dirección de correo electrónico. Entonces, si nos encontramos con un servidor de correo lento o un servidor de correo con un algoritmo de lista gris, obtendrá un resultado desconocido. Siempre puede volver a validar esas condiciones, cargando un archivo en validador de correo electrónico masivo .

En promedio, el 96-98% de todos los dominios volverá en 1 a 5 segundos, hay un puñado de dominios que se ejecutan en Postfix / Dovecot que tienen un tiempo de conexión de 20 segundos para validaciones en tiempo real y muy pequeño porcentaje fraccionario de otros dominios que responden muy lentamente a las consultas SMTP. Todo el ISP principal volverá en 1 a 3 segundos, que generalmente es la mayoría de la distribución de correo electrónico.

- GET / v2 / validar

URL de API: https://api.zerobounce.net/v2/validate

A continuación encontrará las instrucciones sobre cómo usar nuestra API, es muy fácil de usar y requiere SSL. La API requiere que tenga un saldo de crédito activo y nunca consumirá un crédito por ningún resultado desconocido.

Parámetros URL

  • Parámetro
    Descripción
  • CORREO ELECTRÓNICO
    La dirección de correo electrónico que desea validar
  • dirección ip
    La dirección IP desde la que se registró el correo electrónico (puede estar en blanco, pero se requiere un parámetro)
  • clave api
    Su clave API, que se encuentra en su cuenta.

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

  • https://api.zerobounce.net/v2/validate?api_key=replacewithyours&email=valid@example.com&ip_address=156.124.12.145

Para verificar una dirección de correo electrónico, use los siguientes códigos para los siguientes idiomas:

  • 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 api_key COMO Cuerda = "Tu llave secreta"
    Oscuro emailToValidate COMO Cuerda = "example@example.com"
    Oscuro ip_address = "" 'Puede estar en blanco, pero se requiere un parámetro en la llamada a la API
    Oscuro responseString COMO Cuerda = ""
  
    Oscuro apiURL COMO Cuerda = "https://api.zerobounce.net/v2/validate?api_key=" & api_key & "& email =" &  HttpUtility.UrlEncode(emailToValidate) & "& ip_address =" & Sistema.Net.WebUtility.UrlEncode(ip_address)
  
    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 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;
      }
    }
      

Respuesta exitosa

      
  {
    "habla a":"flowerjill@aol.com",
    "estado":"válido",
    "sub_status":"",
    "correo electrónico gratuito":Cierto,
    "querías decir":nulo,
    "cuenta":"flowerjill",
    "dominio":"aol.com",
    "domain_age_days": "8426",
    "smtp_provider":"yahoo",
    "mx_record":"mx-aol.mail.gm0.yahoodns.net",
    "mx_found": Cierto,
    "primer nombre":"jill",
    "apellido":"stein",
    "género":"hembra",
    "país":"Estados Unidos",
    "región":"Florida",
    "ciudad":"West Palm Beach",
    "código postal":"33401",
    "procesado en":"2017-04-01 02:48:02.592"
    }
      

Respuesta de error

      
      {"error":"Clave API no válida o su cuenta se quedó sin créditos"}
      // Ejemplo de respuesta de falla usando la API con cualquiera de los métodos Get
      

La API devolverá estos resultados en formato JSON utilizando el método "Validar".

Propiedades JSON

  • Propiedades
    Descripción
  • habla a
    La dirección de correo electrónico que está validando.
  • estado
    [válido, inválido, general, desconocido, spam, abuso, do_not_mail]
  • sub_status
    [antispam_system,
    greylisted, mail_server_temporary_error, forcible_disconnect, mail_server_did_not_respond, timeout_exceeded, failed_smtp_connection, mailbox_quota_exceeded, exception_occurred, possible_traps, role_based, global_suppression, mailbox_not_found, no_dns_entries, failed_syntax_check, possible_typo, unroutable_ip_address, leading_period_removed, does_not_accept_mail, alias_address, role_based_catch_all, desechable, tóxico]
  • cuenta
    La parte de la dirección de correo electrónico antes del símbolo "@".
  • Dominio
    La parte de la dirección de correo electrónico despus del símbolo "@".
  • querías decir
    Solución sugerente para un error tipográfico de correo electrónico
  • domain_age_days
    Antigüedad del dominio de correo electrónico en días o [nulo].
  • correo electrónico gratuito
    [verdadero / falso] Si el correo electrónico proviene de un proveedor gratuito.
  • mx_found
    [verdadero / falso] ¿El dominio tiene un registro MX?
  • mx_record
    El registro MX preferido del dominio.
  • smtp_provider
    El proveedor SMTP del correo electrónico o [nulo] [BETA].
  • nombre de pila
    El primer nombre del propietario del correo electrónico cuando esté disponible o [nulo].
  • apellido
    El apellido del propietario del correo electrónico cuando esté disponible o [nulo].
  • género
    El género del propietario del correo electrónico cuando está disponible o [nulo].
  • ciudad
    La ciudad de la IP pasó.
  • región
    La región / estado de la IP pasada.
  • código postal
    El código postal de la IP pasado.
  • país
    El país de la IP pasó.
  • procesado en
    La hora UTC en que se validó el correo electrónico.

Modo Sandbox (v2)

/ email-validation-api-quickstart / v2-sandbox-mode /

Para ayudarlo a probar cada escenario de códigos de estado y sub_estado con la API, reunimos una lista de correos electrónicos que arrojarán resultados específicos cuando se utilicen con la API para fines de prueba. Las pruebas con estos correos electrónicos no utilizarán ninguno de sus créditos.

Además, también proporcionamos una dirección IP para probar y obtener resultados de GEO-Location.

Aún necesitará usar su CLAVE API con estas direcciones de correo electrónico de prueba.

  • disposable@example.com

  • invalid@example.com

  • valid@example.com

  • toxic@example.com

  • donotmail@example.com

  • spamtrap@example.com

  • abuse@example.com

  • unknown@example.com

  • catch_all@example.com

  • antispam_system@example.com

  • does_not_accept_mail@example.com

  • exception_occurred@example.com

  • failed_smtp_connection@example.com

  • failed_syntax_check@example.com

  • forcible_disconnect@example.com

  • global_suppression@example.com

  • greylisted@example.com

  • leading_period_removed@example.com

  • mail_server_did_not_respond@example.com

  • mail_server_temporary_error@example.com

  • mailbox_quota_exceeded@example.com

  • mailbox_not_found@example.com

  • no_dns_entries@example.com

  • possible_trap@example.com

  • possible_typo@example.com

  • role_based@example.com

  • timeout_exceeded@example.com

  • unroutable_ip_address@example.com

  • free_email@example.com

  • role_based_catch_all@example.com

Puede usar esta IP para probar la ubicación de GEO en la API.

99.110.204.1

Por favor vea nuestro documentación de códigos de estado para aprender más sobre cada estado.

Códigos de estado (v2)

/ email-validation-api-quickstart / v2-status-codes /

Explicación del estado de entregabilidad

  • válido - Estos son correos electrónicos que determinamos que son válidos y seguros para enviarlos por correo electrónico, tendrán una tasa de rebote muy baja de menos de 2%. Si recibe rebotes, puede deberse a que su IP podría estar en la lista negra donde no estaba nuestra IP. A veces existen cuentas de correo electrónico, pero solo aceptan correo de personas en sus listas de contactos. A veces, acelerará la cantidad de correos electrónicos que puede enviar a un dominio específico por hora. Es importante mirar los códigos de rebote SMTP para determinar por qué.
  • inválido - Estos son correos electrónicos que determinamos que no son válidos, elimínelos de su lista de correo. Los resultados son 99.999% precisos.
  • captura -todos: estos correos electrónicos son imposibles de validar sin enviar un correo electrónico real y esperar un rebote. El término Catch-all significa que el servidor de correo electrónico le dice que el correo electrónico es válido, ya sea válido o no. Si desea enviar estas direcciones por correo electrónico, le sugiero que las segmente en un grupo general y sepa que algunas de ellas probablemente rebotarán.
  • trampa de spam - Se cree que estos correos electrónicos son trampas de spam y no deben enviarse por correo. Contamos con tecnología para determinar si ciertos correos electrónicos deben clasificarse como spamtrap. No conocemos todas las direcciones de correo electrónico de spam, pero sí sabemos muchas de ellas. Lea nuestra Guía de trampas de spam para obtener más información.
  • abuso - Estos correos electrónicos son de personas que se sabe que hacen clic en los enlaces de abuso en los correos electrónicos, por lo tanto, abusadores o denunciantes. Recomendamos no enviar estas direcciones por correo electrónico.
  • do_not_mail - Estos correos electrónicos son de empresas, basadas en roles o personas a las que solo desea evitar enviar correos electrónicos. Se desglosan en 6 subcategorías "desechables", "tóxicos", "basados en roles", "basados en roles", "supresión global" y "posible trampa". Examine este archivo y determine si desea enviar esta dirección por correo electrónico. Son direcciones de correo electrónico válidas, pero no deben enviarse por correo en la mayoría de los casos.
  • desconocido - Estos correos electrónicos no pudimos validarlos por un motivo u otro. Los casos típicos son "Su servidor de correo estaba inactivo" o "el sistema antispam nos está bloqueando". En la mayoría de los casos, 80% de incógnitas son direcciones de correo electrónico no válidas / incorrectas. Tenemos las "incógnitas" más bajas de cualquier validador de correo electrónico, y no hacemos esta declaración a la ligera. Pagamos y probamos listas de correo electrónico en más de 50 compañías de validación diferentes para comparar resultados. Si encuentra una gran cantidad de incógnitas, envíelas para volver a validarlas. Recuerde que no se le cobrará por resultados desconocidos, los créditos serán devueltos. Si todavía tiene un gran número, contáctenos y lo revisaremos y verificaremos.

También proporcionamos un código sub_status para ayudar a explicar algunos de los resultados desconocidos e inválidos, no todas las incógnitas e inválidos tendrán códigos sub_status.

Explicación del estado secundario

  • dirección_alias - (válido) Estas direcciones de correo electrónico actúan como reenviadores / alias y no son bandejas de entrada reales, por ejemplo, si envía un correo electrónico a forward@example.com y luego el correo electrónico se reenvía a realinbox@example.com. Es una dirección de correo electrónico válida y puede enviarles, es solo un poco más de información sobre la dirección de correo electrónico. A veces podemos detectar direcciones de correo electrónico de alias y cuando lo hacemos, se lo informamos.
  • sistema antispam - (desconocido) Estos correos electrónicos tienen sistemas anti-spam implementados que nos impiden validar estos correos electrónicos. Puede enviarnos esto a través de la pantalla de contacto para investigar.
  • does_not_accept_mail - (inválido) Estos dominios solo envían correo y no lo aceptan.
  • ocurrió una excepción - (desconocido) Estos correos electrónicos causaron una excepción al validar. Si esto sucede repetidamente, háganoslo saber.
  • failure_smtp_connection - (desconocido) Estos correos electrónicos pertenecen a un servidor de correo que no permitirá una conexión SMTP. La mayoría de las veces, estos correos electrónicos terminarán siendo inválidos.
  • fail_syntax_check - Correos electrónicos (no válidos) que no cumplen con los protocolos de sintaxis RFC
  • desconexión forzada - (Desconocido) Estos correos electrónicos pertenecen a un servidor de correo que se desconecta inmediatamente al conectarse. La mayoría de las veces, estos correos electrónicos terminarán siendo inválidos.
  • global_suppression - (do_not_mail) Estos correos electrónicos se encuentran en muchas listas populares de supresión global (GSL), consisten en denunciantes de ISP conocidos, denunciantes directos, direcciones compradas, dominios que no envían correo y litigantes conocidos.
  • en la lista gris - (Desconocido) Correos electrónicos donde no podemos validarlos temporalmente. Muchas veces, si vuelve a enviar estos correos electrónicos, se validarán en un segundo pase.
  • Leading_period_removed - (válido) Si una dirección de correo electrónico válida de gmail.com comienza con un punto '.' lo eliminaremos, por lo que la dirección de correo electrónico es compatible con todos los sistemas de correo.
  • mail_server_did_not_respond - (desconocido) Estos correos electrónicos pertenecen a un servidor de correo que no responde a los comandos de correo. La mayoría de las veces, estos correos electrónicos terminarán siendo inválidos.
  • mail_server_temporary_error - (desconocido) Estos correos electrónicos pertenecen a un servidor de correo que devuelve un error temporal. La mayoría de las veces, estos correos electrónicos terminarán siendo inválidos.
  • Ha superado la cuota de buzón - (inválido) Estos correos electrónicos excedieron su cuota de espacio y no aceptan correos electrónicos. Estos correos electrónicos están marcados como no válidos.
  • buzón_no_encontrado - (no válido) Estas direcciones de correo electrónico son válidas en sintaxis, pero no existen. Estos correos electrónicos están marcados como no válidos.
  • no_dns_entries - (no válido) Estos correos electrónicos son válidos en sintaxis, pero el dominio no tiene ningún registro en DNS o tiene registros DNS incompletos. Por lo tanto, los programas de correo no podrán o tendrán dificultades para enviarles. Estos correos electrónicos están marcados como no válidos.
  • posible_trampa - (do_not_mail) Estos correos electrónicos contienen palabras clave que pueden correlacionarse con posibles trampas de spam como spam @ o @ spamtrap.com. Examínelos antes de decidir enviarles correos electrónicos o no.
  • possible_typo - (inválido) Estos son correos electrónicos de dominios populares comúnmente mal escritos. Estos correos electrónicos están marcados como no válidos.
  • basado en roles - (do_not_mail) Estos correos electrónicos pertenecen a un puesto o un grupo de personas, como sales @ info @ y contact @. Los correos electrónicos basados en roles tienen una fuerte correlación con las personas que informan los correos que se les envían como spam y abuso.
  • timeout_exceeded - (desconocido) Estos correos electrónicos pertenecen a un servidor de correo que responde extremadamente lento. La mayoría de las veces, estos correos electrónicos terminarán siendo inválidos.
  • unroutable_ip_address - (inválido) Estos dominios de correo electrónico apuntan a una dirección IP no enrutable, estos están marcados como inválidos.
  • desechable - (do_not_mail) Estos son correos electrónicos temporales creados con el único propósito de registrarse en sitios web sin dar su dirección de correo electrónico real. Estos correos electrónicos son de corta duración de 15 minutos a alrededor de 6 meses. Solo hay 2 valores (verdadero y falso). Si tiene correos electrónicos válidos con este indicador establecido en VERDADERO, no debe enviarlos por correo electrónico.
  • tóxico - (do_not_mail) Se sabe que estas direcciones de correo electrónico son correos electrónicos creados por abuso, spam o bot. Si tiene correos electrónicos válidos con este indicador establecido en VERDADERO, no debe enviarlos por correo electrónico.

También proporcionamos otros campos adicionales que debe tener en cuenta antes de enviar un correo electrónico. Si alguno de sus correos electrónicos válidos tiene el indicador desechable o tóxico establecido en verdadero, le recomendamos que no los envíe por correo electrónico.

  • role_based_catch_all - (do_not_mail) Estos correos electrónicos están basados en roles y también pertenecen a un dominio catch_all.

Otros campos

  • correo electrónico gratuito - [verdadero / falso] Si el correo electrónico proviene de un proveedor gratuito.
  • mx_found - [verdadero / falso] ¿El dominio tiene un registro MX?
  • mx_record - El registro MX preferido del dominio.
  • smtp_provider - El proveedor SMTP del correo electrónico o [nulo] (BETA).

V2 cambios

/ email-validation-api-quickstart / v2-changes /

Estos son los elementos que cambiaron entre v1 y v2.

  1. Los correos electrónicos desechables y tóxicos se han movido bajo el estado do_not_mail con el sub_status apropiado (tóxico, desechable)

  2. El estado "DoNotMail" se cambió a "do_not_mail"

  3. Todos los estados ahora están en minúsculas, en lugar de mayúsculas y minúsculas.

  4. Agregamos una propiedad free_email para indicar si el dominio de correo electrónico es un proveedor de correo electrónico gratuito que puede usarse para [prevención de fraude].

  5. Agregamos una propiedad domain_age_days para informarle la antigüedad del dominio [prevención de fraude].

  6. Agregamos la propiedad smtp_provider para el dominio de correo electrónico, esta característica está en beta.

  7. Agregamos la propiedad mx_found, para informarle si el dominio tiene un registro MX

  8. Agregamos la propiedad mx_record, para indicarle el registro MX preferido del dominio.

  9. Agregamos la propiedad did_you_mean, que se completará si se detecta un error tipográfico con una corrección sugerida.

  10. La propiedad apiKey se cambió a api_key

  11. La propiedad IPAddress se cambió a ip_address

  12. El método validatewithip fue eliminado, ahora es parte del método validar

  13. Se eliminó la propiedad de ubicación (no se estaba usando)

  14. La propiedad creation_date se eliminó (no se estaba usando)

  15. la propiedad processedat ahora se procesa_at

  16. Agregamos un nuevo sub_status llamado "role_based_catch_all"

  17. Agregamos tres nuevas API, sendfile, filestatus y getfile para la validación masiva de correo electrónico.

Enviar archivo (v2)

/ email-validation-api-quickstart / v2-send-file /

La API sendfile permite al usuario enviar un archivo para la validación masiva de correo electrónico. El tipo de contenido debe ser multipart / form-data. Consulte el ejemplo de C # para más detalles.

POST / v2 / sendfile

URL de API: https://bulkapi.zerobounce.net/v2/sendfile

Parámetros URL

  • Parámetro
    Descripción
  • expediente
    archivo csv o txt. Contenido de la matriz de bytes para el archivo enviado. El encabezado del contenido es tipo "text / csv".
  • clave api
    Su clave API, que se encuentra en su cuenta. (Necesario)
  • return_url
    La URL se utilizará para devolver la llamada cuando se complete la validación. (Opcional)
  • email_address_column
    El índice de columna de la dirección de correo electrónico en el archivo. El índice comienza desde 1. (Necesario)
  • nombre_columna_nombre
    El índice de columna de la columna de nombre. (Opcional)
  • apellido_columna
    El índice de columna de la columna de apellido. (Opcional)
  • género_columna
    El índice de columna de la columna de género. (Opcional)
  • ip_address_column
    La dirección IP desde la que se registró el correo electrónico. (Opcional)
  • has_header_row
    Si la primera fila del archivo enviado es una fila de encabezado. verdadero o falso (opcional)

Si se especificó return_url en los Datos del formulario multiparte durante la solicitud del archivo de envío, PUBLICAREMOS los siguientes datos en la URL cuando se complete el proceso de validación.


                {
                  file_id": "aaaaaaaa-zzzz-xxxx-yyyy-5003727fffff",
                  "nombre del archivo": "Su nombre de archivo.csv", 
                  "fecha de carga": "10/20/2018 4:35: 58 PM" 
                }
                

Enviar muestras de código de archivo

  • 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

'Enviar muestra de archivo en VB.net

Público Clase SendFileStatus
    Público PROPIEDAD success COMO Booleano
    Público PROPIEDAD message COMO Cuerda
    Público PROPIEDAD file_name COMO Cuerda
    Público PROPIEDAD file_id COMO Cuerda
Fin Clase

Privado Compartido SUB SendFileAPITest()
    Oscuro fileFullPath COMO Cuerda = $"ruta de archivo completa de un archivo csv o txt"  'requerido
    Oscuro apiKey COMO Cuerda = "reemplace con su clave de api aquí"              'requerido
    Oscuro emailAddressColumn COMO Entero = 2  'requerido
    Oscuro firstNameColumn COMO Entero? = 5    ' opcional
    Oscuro lastNameColumn COMO Entero? = 6     ' opcional
    Oscuro genderColumn COMO Entero? = Nada ' opcional
    Oscuro ipAddressColumn COMO Entero? = 11   ' opcional
    Oscuro hasHeaderRow COMO Booleano? = Cierto    ' opcional
    Oscuro returnUrl COMO Cuerda = Nada      ' opcional

    Tratar
        Oscuro sendFileStatus COMO SendFileStatus = SendFile(fileFullPath, apiKey, emailAddressColumn, firstNameColumn, lastNameColumn, genderColumn, ipAddressColumn, hasHeaderRow, returnUrl).Result
        Console.Escribir(JsonConvert.SerializeObject(sendFileStatus, Formatting.Indented))
    Captura ex COMO Exception
        Console.Escribir(ex.InnerException.Message)
    Fin Tratar

    Console.ReadKey()
Fin SUB

Público Compartido Async Función SendFile(Byval fileFullPath COMO Cuerda, 
                                      Byval apiKey COMO Cuerda, 
                                      Byval emailAddressColumn COMO Entero, 
                                      Byval Opcional firstNameColumn COMO Entero? = Nada, 
                                      Byval Opcional lastNameColumn COMO Entero? = Nada, 
                                      Byval Opcional genderColumn COMO Entero? = Nada, 
                                      Byval Opcional ipAddressColumn COMO Entero? = Nada, 
                                      Byval Opcional hasHeaderRow COMO Booleano? = Nada, 
                                      Byval Opcional returnUrl COMO Cuerda = Nada) COMO Task(De SendFileStatus)

    Si Cuerda.IsNullOrEmpty(fileFullPath) Entonces Lanzar NUEVO Exception("Error: se requiere fileFullPath")
    Si Cuerda.IsNullOrEmpty(apiKey) Entonces Lanzar NUEVO Exception("Error: se requiere apiKey")
    Oscuro fi = NUEVO FileInfo(fileFullPath)
    Oscuro fileContents = File.ReadAllBytes(fi.FullName)
    Oscuro fileName = fi.Nombre
    Oscuro uri COMO Uri = NUEVO Uri("https://bulkapi.zerobounce.net/v2/sendfile")

    Utilizando client = NUEVO HttpClient()

        Utilizando request = NUEVO HttpRequestMessage(HttpMethod.Post, uri)
            Oscuro multiPartContent COMO MultipartFormDataContent = NUEVO MultipartFormDataContent()
            Oscuro byteArrayContent COMO ByteArrayContent = NUEVO ByteArrayContent(fileContents)
            byteArrayContent.Headers.Add("Tipo de contenido", "texto / csv")
            multiPartContent.Add(byteArrayContent, "expediente", fileName)
            multiPartContent.Add(NUEVO StringContent(apiKey), "clave api")
            multiPartContent.Add(NUEVO StringContent(emailAddressColumn.ToString()), "email_address_column")
            Si firstNameColumn No es Nada Entonces multiPartContent.Add(NUEVO StringContent(firstNameColumn.ToString()), "nombre_columna_nombre")
            Si lastNameColumn No es Nada Entonces multiPartContent.Add(NUEVO StringContent(lastNameColumn.ToString()), "apellido_columna")
            Si genderColumn No es Nada Entonces multiPartContent.Add(NUEVO StringContent(genderColumn.ToString()), "género_columna")
            Si ipAddressColumn No es Nada Entonces multiPartContent.Add(NUEVO StringContent(ipAddressColumn.ToString()), "ip_address_column")
            Si hasHeaderRow No es Nada Entonces multiPartContent.Add(NUEVO StringContent(Si((hasHeaderRow = Cierto), "cierto", "falso")), "has_header_row")
            Si returnUrl No es Nada Entonces multiPartContent.Add(NUEVO StringContent(returnUrl.ToString()), "return_url")
            request.Content = multiPartContent

            Utilizando response = Await client.SendAsync(request, HttpCompletionOption.ResponseContentRead, CancellationToken.None).ConfigureAwait(Falso)
                Oscuro content = Await response.Content.ReadAsStringAsync()

                Si response.IsSuccessStatusCode = Falso Entonces
                    Oscuro error COMO Cuerda = $"StatusCode = {Cinturones(response.StatusCode)}, Content = {content}"
                    Lanzar NUEVO Exception(error)
                Fin Si

                Regreso JsonConvert.DeserializeObject(De SendFileStatus)(content)
            Fin Utilizando
        Fin Utilizando
    Fin Utilizando
Fin Función
    

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

Respuesta de punto final

Respuesta exitosa

      
{
  "éxito": Cierto,
  "mensaje": "Archivo aceptado",
  "nombre del archivo": "Su nombre de archivo.csv",
  "file_id": "aaaaaaaa-zzzz-xxxx-aaaa- 5003727 fffff"
}
    

Respuesta de error

      
    {
      "éxito": Falso,
      "mensaje": [
          "Error de mensajes"
      ]
  }
    

Estado del archivo (v2)

/ email-validation-api-quickstart / v2-file-status /

La API de estado de archivos devuelve el estado de procesamiento del archivo enviado mediante la API sendfile. Consulte el ejemplo de C # para más detalles.

GET / v2 / filestatus

URL de API: https://bulkapi.zerobounce.net/v2/filestatus

Parámetros URL

  • Parámetro
    Descripción
  • clave api
    Su clave API, que se encuentra en su cuenta.
  • file_id
    El ID de archivo devuelto al llamar a la API sendfile.

If you want to call the API from your browser to test it, all you have to do is to replace the API KEY with your key and the FILE ID with the returned file ID from sendfile API:

https://bulkapi.zerobounce.net/v2/filestatus?api_key=[replacewithyours]&file_id=[replacewithyours]

Muestras de código de estado de archivo

  • 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

'Muestra de estado de archivo en VB.net

Público Clase FileStatus
    Público PROPIEDAD success COMO Booleano
    Público PROPIEDAD file_id COMO Cuerda
    Público PROPIEDAD file_name COMO Cuerda
    Público PROPIEDAD upload_date COMO Cuerda
    Público PROPIEDAD file_status COMO Cuerda
    Público PROPIEDAD complete_percentage COMO Cuerda
    Público PROPIEDAD return_url COMO Cuerda
Fin Clase

Privado Compartido SUB FileStatusAPITest()
    Oscuro apiKey COMO Cuerda = "reemplace con su clave de api aquí"
    Oscuro fileID COMO Cuerda = "reemplazar con el ID de archivo devuelto al llamar a la API sendfile"

    Tratar
        Oscuro fileStatus COMO FileStatus = FileStatusAsync(apiKey, fileID).Result
        Console.Escribir(JsonConvert.SerializeObject(fileStatus, Formatting.Indented))
    Captura ex COMO Exception
        Console.Escribir(ex.InnerException.Message)
    Fin Tratar

    Console.ReadKey()
Fin SUB

Público Compartido Async Función FileStatusAsync(Byval apiKey COMO Cuerda, Byval fileID COMO Cuerda) COMO Task(De FileStatus)
    Si Cuerda.IsNullOrEmpty(apiKey) Entonces Lanzar NUEVO Exception("Error: se requiere apiKey")
    Si Cuerda.IsNullOrEmpty(fileID) Entonces Lanzar NUEVO Exception("Error: se requiere ID de archivo")
    Oscuro uri COMO Uri = NUEVO Uri($"https://bulkapi.zerobounce.net/v2/filestatus?api_key={apiKey}&file_id={fileID}")

    Utilizando client = NUEVO HttpClient()
        Utilizando request = NUEVO HttpRequestMessage(HttpMethod.obtener, uri)
            Utilizando response = Await client.SendAsync(request).ConfigureAwait(Falso)
                Oscuro content = Await response.Content.ReadAsStringAsync()

                Si response.IsSuccessStatusCode = Falso Entonces
                    Oscuro error COMO Cuerda = $"StatusCode = {Cinturones(response.StatusCode)}, Content = {content}"
                    Lanzar NUEVO Exception(error)
                Fin Si

                Regreso JsonConvert.DeserializeObject(De FileStatus)(content)
            Fin Utilizando
        Fin Utilizando
    Fin Utilizando
Fin Función
    

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

// Muestra de estado de archivo en C #

Público Clase Estado de los archivos
{
    Público bool success { obtener; conjunto; }
    Público Cuerda file_id { obtener; conjunto; }
    Público Cuerda file_name { obtener; conjunto; }
    Público Cuerda upload_date { obtener; conjunto; }
    Público Cuerda file_status { obtener; conjunto; }
    Público Cuerda complete_percentage { obtener; conjunto; }
    Público Cuerda return_url { obtener; conjunto; }
}

Privado estático vacío Filestatusapitest()
{
    Cuerda apiKey = "reemplace con su clave de api aquí";
    Cuerda fileID = "reemplazar con el ID de archivo devuelto al llamar a la API sendfile";

    Tratar
    {
        Estado de los archivos fileStatus = Filestatusasync(apiKey, fileID).Result;
        Console.Escribir(JsonConvert.Serializeobject(fileStatus, Formatting.Indented));
    }
    Captura (Excepción ex)
    {
        Console.Escribir(ex.InnerException.Message);
    }
    Console.Leer la clave();
}

Público estático asíncrono Task<FileStatus> Filestatusasync(Cuerda apiKey, Cuerda fileID)
{
    Si (Cuerda.Isnullorempty(apiKey))
        Lanzar NUEVO Excepción("Error: se requiere apiKey");
    Si (Cuerda.Isnullorempty(fileID))
        Lanzar NUEVO Excepción("Error: se requiere ID de archivo");

    Uri uri = NUEVO Uri($"https://bulkapi.zerobounce.net/v2/filestatus?api_key={apiKey}&file_id={fileID}");

    Utilizando (var client = NUEVO Httpclient())
    Utilizando (var request = NUEVO Httprequestmessage(HttpMethod.Get, uri))
    Utilizando (var response = esperar client.Sendasync(request).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<Estado de los archivos>(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/filestatus?api_key=replacewithyours&file_id=replacewithyours",
      CURLOPT_RETURNTRANSFER => Cierto,
      CURLOPT_ENCODING => "",
      CURLOPT_MAXREDIRS => 10,
      CURLOPT_TIMEOUT => 30,
      CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
      CURLOPT_CUSTOMREQUEST => "OBTENER",
      CURLOPT_POSTFIELDS => "",
      CURLOPT_HTTPHEADER => formación(
        "Ficha de cartero: 91504 cea-f92f- 46 b0- 97 a4- 338167072887",
        "control de caché: sin caché"
      ),
    ));
    
    $ 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();

    Solicitud request = NUEVO Solicitud.Constructor()
      .url("https://bulkapi.zerobounce.net/v2/filestatus?api_key=replacewithyours&file_id=replacewithyours")
      .obtener()
      .addheader("control de caché", "sin caché")
      .addheader("Ficha de cartero", "7 fffd7a4-b2fd- 4 e8b-ac85- 4099411 f27ce")
      .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 = ""
    
    headers = {
        'control de caché': "sin caché",
        'Ficha de cartero': "caa917fe- 45 ce- 45 ae- 9456-2 b039b999dcb"
        }
    
    conn.request("OBTENER", "v2, estado de archivos", 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

    // Seleccione el lenguaje VB o C # para File Status Sampleimport Foundation

    dejar headers = [
      "control de caché": "sin caché",
      "Ficha de cartero": "4 f1b92e2- 034 f- 4 fa0- 94 d9-b097d768668a"
    ]
    
    dejar request = Nsmutableurlrequest(url: NSURL(string: "https://bulkapi.zerobounce.net/v2/filestatus?api_key=replacewithyours&file_id=replacewithyours")! COMO url,
                                            cachePolicy: .useProtocolCachePolicy,
                                        timeoutInterval: 10.0)
    request.httpMethod = "OBTENER"
    request.allHTTPHeaderFields = headers
    
    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


    #importar <Foundation/Foundation.h>

    NSDictionary *headers = @{ @ "control de caché": @ "sin caché",
                               @ "Cartero-Token": @"5e9c24ae-b577-4e33-8748-83f14e151ae9" };
    
    NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"https://bulkapi.zerobounce.net/v2/filestatus?api_key=replacewithyours&file_id=replacewithyours"]
                                                           cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                       timeoutInterval:10.0];
    [request setHTTPMethod:@"OBTENER"];
    [request setAllHTTPHeaderFields:headers];
    
    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
    

Respuesta de punto final

Respuesta exitosa

      
{
  "éxito": Cierto,
  "file_id": "aaaaaaaa-zzzz-xxxx-aaaa- 5003727 fffff",
  "nombre del archivo": "Su nombre de archivo.csv",
  "fecha de carga": "10/20/2018 4:35: 58 PM",
  "file_status": "Completar",
  "porcentaje_completo": "100%",
  "return_url": "Su URL de retorno si se proporciona al llamar a la API sendfile"
}
    

Respuesta de error


    {      
      "éxito": Falso,
      "mensaje": "Error de mensajes"
    }
    

Obtener archivo (v2)

/ email-validation-api-quickstart / v2-get-file /

La API getfile permite a los usuarios obtener el archivo de resultados de validación para el archivo enviado mediante la API sendfile. Consulte el ejemplo de C # para más detalles.

GET / v2 / getfile

URL de API: https://bulkapi.zerobounce.net/v2/getfile

Parámetros URL

  • Parámetro
    Descripción
  • clave api
    Su clave API, que se encuentra en su cuenta.
  • file_id
    El ID de archivo devuelto al llamar a la API sendfile.

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 y la ID DE ARCHIVO con la ID del archivo devuelto de enviar archivo API:

https://bulkapi.zerobounce.net/v2/getfile?api_key=replacewithyours&file_id=[replacewithyours]

Ejemplos de código GetFile

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

'Obtener muestra de archivo en VB.net

Privado Compartido SUB GetFileAPITest()
  Oscuro apiKey COMO Cuerda = "reemplace con su clave de api aquí"
  Oscuro fileID COMO Cuerda = "reemplazar con el ID de archivo devuelto al llamar a la API sendfile"
  Oscuro dir COMO Cuerda = "C:	emp"

    Tratar
        Oscuro filePath = GetFileAsync(apiKey, fileID, dir).Result
        Console.Escribir($"File {filePath} retrieved successfully.")
    Captura ex COMO Exception
        Console.Escribir(ex.InnerException.Message)
    Fin Tratar

    Console.ReadKey()
Fin SUB

Público Compartido Async Función GetFileAsync(Byval apiKey COMO Cuerda, Byval fileID COMO Cuerda, Byval dir COMO Cuerda) COMO Task(De Cuerda)
    Si Cuerda.IsNullOrEmpty(apiKey) Entonces Lanzar NUEVO Exception("Error: se requiere apiKey")
    Si Cuerda.IsNullOrEmpty(fileID) Entonces Lanzar NUEVO Exception("Error: se requiere ID de archivo")
    Oscuro uri COMO Uri = NUEVO Uri($"https://bulkapi.zerobounce.net/v2/getfile?api_key={apiKey}&file_id={fileID}")

    Utilizando client = NUEVO HttpClient()
        Utilizando request = NUEVO HttpRequestMessage(HttpMethod.obtener, uri)
            Utilizando response = Await client.SendAsync(request, HttpCompletionOption.ResponseHeadersRead).ConfigureAwait(Falso)
                Utilizando streamToReadFrom COMO Corriente = Await response.Content.ReadAsStreamAsync()

                    Si response.IsSuccessStatusCode = Falso Entonces
                        Oscuro [error] = $"StatusCode = {Cinturones(response.StatusCode)}, Content = {response.Content.ReadAsStringAsync().Result}"
                        Lanzar NUEVO Exception([error])
                    Fin Si

                    Oscuro filePath = Path.Combine(dir, response.Content.Headers.ContentDisposition.FileName)

                    Utilizando streamToWriteTo COMO Corriente = File.Abierto(filePath, FileMode.Create)
                        Await streamToReadFrom.CopyToAsync(streamToWriteTo)
                    Fin Utilizando

                    Regreso filePath
                Fin Utilizando
            Fin Utilizando
        Fin Utilizando
    Fin Utilizando
Fin Función
    

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

// Obtener muestra de archivo en C #

Privado estático vacío Getfileapitest()
{
    Cuerda apiKey = "reemplace con su clave de api aquí";
    Cuerda fileID = "reemplazar con el ID de archivo devuelto al llamar a la API sendfile";
    Cuerda dir = @ "C: emp";  // especifica el directorio donde deseas guardar el archivo de resultados

    Tratar
    {              
        var filePath = Getfileasync(apiKey, fileID, dir).Result;
        Console.Escribir($"Archivo {filePath} recuperado con éxito".);
    }
    Captura (Excepción ex)
    {
        Console.Escribir(ex.InnerException.Message);
    }
    Console.Leer la clave();
}

Público estático asíncrono Task<Cuerda> Getfileasync(Cuerda apiKey, Cuerda fileID, Cuerda dir)
{
    Si (Cuerda.Isnullorempty(apiKey))
        Lanzar NUEVO Excepción("Error: se requiere apiKey");
    Si (Cuerda.Isnullorempty(fileID))
        Lanzar NUEVO Excepción("Error: se requiere ID de archivo");

    Uri uri = NUEVO Uri($"https://bulkapi.zerobounce.net/v2/getfile?api_key={apiKey}&file_id={fileID}");

    Utilizando (var client = NUEVO Httpclient())
    Utilizando (var request = NUEVO Httprequestmessage(HttpMethod.Get, uri))
    Utilizando (var response = esperar client.Sendasync(request, HttpCompletionOption.ResponseHeadersRead).Configureawait(Falso))
    Utilizando (Corriente streamToReadFrom = esperar response.Content.Readasstreamasync())
    {
        Si (response.IsSuccessStatusCode == Falso)
        {
            var error = $"StatusCode = {(int) response.StatusCode}, Content = {response.Content.ReadAsStringAsync (). Resultado}";
            Lanzar NUEVO Excepción(error);
        }

        var filePath = Path.Combinar(dir, response.Content.Headers.ContentDisposition.FileName);
        Utilizando (Corriente streamToWriteTo = File.Abierto(filePath, FileMode.Create))
        {
            esperar streamToReadFrom.Copytoasync(streamToWriteTo);
        }
        Regreso filePath;
    }
}
    

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

  $ solicitud = NUEVO Solicitud HTTP();
  $ solicitud->seturl('https://bulkapi.zerobounce.net/v2/getfile');
  $ solicitud->método establecido(HTTP_METH_GET);
  
  $ solicitud->setquerydata(formación(
    'clave api' => 'replacewithyours',
    'file_id' => 'replacewithyours'
  ));
  
  $ solicitud->setheaders(formación(
    'Ficha de cartero' => '0 a6c40b8- 0 cd4- 4 dbb-a57e- 422558 e7ab6a',
    'control de caché' => 'no-cache'
  ));
  
  Tratar {
    $ respuesta = $ solicitud->enviar();
  
    eco $ respuesta->getbody();
  } Captura (Httpexception $ ex) {
    eco $ ex;
  }
  ?>
    


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

  Solicitud request = NUEVO Solicitud.Constructor()
    .url("https://bulkapi.zerobounce.net/v2/getfile?api_key=replacewithyours&file_id=replacewithyours")
    .obtener()
    .addheader("control de caché", "sin caché")
    .addheader("Ficha de cartero", "d0b7d318-f3f6- 47 fb- 842 d- 5622 b26592c1")
    .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 = ""
  
  headers = {
      'control de caché': "sin caché",
      'Ficha de cartero': "9 f615d7e- 60 af- 4746-9 bcc- 317 b1f80a6bb"
      }
  
  conn.request("OBTENER", "v2, getfile", 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 = [
  "control de caché": "sin caché",
  "Ficha de cartero": "6 c8cb1cb- 25 ed- 4 e56-b4cb- 65 e949b8bdd1"
]

dejar request = Nsmutableurlrequest(url: NSURL(string: "https://bulkapi.zerobounce.net/v2/getfile?api_key=replacewithyours&file_id=replacewithyours")! COMO url,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "OBTENER"
request.allHTTPHeaderFields = headers

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()
    

Respuesta de punto final

Respuesta exitosa

      
    //N/A
    

La API getfile devuelve el archivo de resultados de validación. El tipo de contenido devuelto es "application / octet-stream". Puede obtener el nombre del archivo de response.Content.Headers.ContentDisposition.FileName. Si está llamando a la API directamente desde el navegador, puede guardar o abrir el archivo de resultados desde el navegador.

Respuesta de error

      
  {
      "éxito": Falso,
      "mensaje": "Error de mensajes"
  }
    

Eliminar archivo (v2)

/ email-validation-api-quickstart / v2-delete-file /

La API deletefile elimina el archivo que se envió usando enviar archivo API El archivo solo se puede eliminar cuando su estado es Completo.

POST / v2 / deletefile

URL de API: https://bulkapi.zerobounce.net/v2/deletefile

Parámetros URL

  • Parámetro
    Descripción
  • clave api
    Su clave API, que se encuentra en su cuenta.
  • file_id
    El ID de archivo devuelto al llamar a la API sendfile.

Eliminar muestras de código de archivo

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

'Eliminar muestra de archivo en VB.net

Público Clase ResponseResult
    Público PROPIEDAD success COMO Booleano
    Público PROPIEDAD message COMO Cuerda
    Público PROPIEDAD file_id COMO Cuerda
    Público PROPIEDAD file_name COMO Cuerda
Fin Clase

Privado Compartido SUB DeleteFileAPITest()
    Oscuro apiKey COMO Cuerda = "reemplace con su clave de api aquí"
    Oscuro fileID COMO Cuerda = "reemplazar con el ID de archivo devuelto al llamar a la API sendfile"

    Tratar
        Oscuro responseResult COMO ResponseResult = DeleteFileAsync(apiKey, fileID).Result
        Console.Escribir(JsonConvert.SerializeObject(responseResult, Formatting.Indented))
    Captura ex COMO Exception
        Console.Escribir(ex.InnerException.Message)
    Fin Tratar

    Console.ReadKey()
Fin SUB

Público Compartido Async Función DeleteFileAsync(Byval apiKey COMO Cuerda, Byval fileID COMO Cuerda) COMO Task(De ResponseResult)
    Si Cuerda.IsNullOrEmpty(apiKey) Entonces Lanzar NUEVO Exception("Error: se requiere apiKey")
    Si Cuerda.IsNullOrEmpty(fileID) Entonces Lanzar NUEVO Exception("Error: se requiere ID de archivo")
    Oscuro uri COMO Uri = NUEVO Uri($"https://bulkapi.zerobounce.net/v2/deletefile?api_key={apiKey}&file_id={fileID}")

    Utilizando client = NUEVO HttpClient()

        Utilizando request = NUEVO HttpRequestMessage(HttpMethod.[obtener], uri)

            Utilizando response = Await client.SendAsync(request).ConfigureAwait(Falso)
                Oscuro content = Await response.Content.ReadAsStringAsync()

                Si response.IsSuccessStatusCode = Falso Entonces
                    Oscuro [error] = $"StatusCode = {Cinturones(response.StatusCode)}, Content = {content}"
                    Lanzar NUEVO Exception([error])
                Fin Si

                Regreso JsonConvert.DeserializeObject(De ResponseResult)(content)
            Fin Utilizando
        Fin Utilizando
    Fin Utilizando
Fin Función
    

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

// Eliminar muestra de archivo en C #

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

Privado estático vacío Deletefileapitest()
{
    Cuerda apiKey = "reemplace con su clave de api aquí";
    Cuerda fileID = "reemplazar con el ID de archivo devuelto al llamar a la API sendfile";

    Tratar
    {
        RespuestaResultado responseResult = Deletefileasync(apiKey, fileID).Result;
        Console.Escribir(JsonConvert.Serializeobject(responseResult, Formatting.Indented));
    }
    Captura (Excepción ex)
    {
        Console.Escribir(ex.InnerException.Message);
    }
    Console.Leer la clave();
}

Público estático asíncrono Task<ResponseResult> Deletefileasync(Cuerda apiKey, Cuerda fileID)
{
    Si (Cuerda.Isnullorempty(apiKey))
        Lanzar NUEVO Excepción("Error: se requiere apiKey");
    Si (Cuerda.Isnullorempty(fileID))
        Lanzar NUEVO Excepción("Error: se requiere ID de archivo");

    Uri uri = NUEVO Uri($"https://bulkapi.zerobounce.net/v2/deletefile?api_key={apiKey}&file_id={fileID}");

    Utilizando (var client = NUEVO Httpclient())
    Utilizando (var request = NUEVO Httprequestmessage(HttpMethod.Get, uri))
    Utilizando (var response = esperar client.Sendasync(request).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<RespuestaResultado>(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/deletefile?api_key=replacewithyours&file_id=replacewithyours",
    CURLOPT_RETURNTRANSFER => Cierto,
    CURLOPT_ENCODING => "",
    CURLOPT_MAXREDIRS => 10,
    CURLOPT_TIMEOUT => 30,
    CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
    CURLOPT_CUSTOMREQUEST => "OBTENER",
    CURLOPT_POSTFIELDS => "",
    CURLOPT_HTTPHEADER => formación(
      "Ficha de cartero: 91504 cea-f92f- 46 b0- 97 a4- 338167072887",
      "control de caché: sin caché"
    ),
  ));
  
  $ 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();

Solicitud request = NUEVO Solicitud.Constructor()
  .url("https://bulkapi.zerobounce.net/v2/deletefile?api_key=replacewithyours&file_id=replacewithyours")
  .obtener()
  .addheader("control de caché", "sin caché")
  .addheader("Ficha de cartero", "7 fffd7a4-b2fd- 4 e8b-ac85- 4099411 f27ce")
  .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 = ""

headers = {
    'control de caché': "sin caché",
    'Ficha de cartero': "caa917fe- 45 ce- 45 ae- 9456-2 b039b999dcb"
    }

conn.request("OBTENER", "v2, archivo de eliminación", 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

// Seleccione el lenguaje VB o C # para File Status Sampleimport Foundation

dejar headers = [
  "control de caché": "sin caché",
  "Ficha de cartero": "4 f1b92e2- 034 f- 4 fa0- 94 d9-b097d768668a"
]

dejar request = Nsmutableurlrequest(url: NSURL(string: "https://bulkapi.zerobounce.net/v2/deletefile?api_key=replacewithyours&file_id=replacewithyours")! COMO url,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "OBTENER"
request.allHTTPHeaderFields = headers

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

#importar <Foundation/Foundation.h>

NSDictionary *headers = @{ @ "control de caché": @ "sin caché",
                            @ "Cartero-Token": @"5e9c24ae-b577-4e33-8748-83f14e151ae9" };

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"https://bulkapi.zerobounce.net/v2/deletefile?api_key=replacewithyours&file_id=replacewithyours"]
                                                        cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                    timeoutInterval:10.0];
[request setHTTPMethod:@"OBTENER"];
[request setAllHTTPHeaderFields:headers];

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

Respuesta de punto final

Respuesta exitosa

      
  {
    "éxito": Cierto,
    "mensaje": "Archivo eliminado",
    "nombre del archivo": "prueba2",
    "file_id": "b222a0fd- 90 d5- 416 c- 8 f1a- 9 cc3851fc823"
  }
    

Respuesta de error

      
{
  "éxito": Falso,
  "mensaje": "No se puede encontrar el archivo".
}