Cómo usar la API ZeroBounce

Validar correos electrónicos (v1)

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 nuestra documentación de sandbox.

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 al 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.

OBTENER / v1 / validar

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

URL de API (con GEO Append): https://bulkapi.zerobounce.net/v1/validatewithip

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/v1/validatewithip?apikey=replacewithyours&email=valid@example.com&ipAddress=156.124.12.145

o si no necesita GEO Append simplemente llame al método de validación.

https://api.zerobounce.net/v1/validate?apikey=replacewithyours&email=valid@example.com

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

  • 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]
  • 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 "@".
  • desechable
    [verdadero, falso] Si el dominio de correo electrónico es desechable, que generalmente son direcciones de correo electrónico temporales.
  • tóxico
    [verdadero, falso] Se sabe que estas direcciones de correo electrónico son abuso, spam o bot creado.
  • 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].
  • fecha de creación
    La fecha de creación del correo electrónico cuando está disponible o [nulo] [Obsoleto].
  • ubicación
    La ubicación del propietario del correo electrónico cuando esté disponible o [nulo] [Obsoleto].
  • Procesado en
    La hora UTC en que se validó el correo electrónico.

La API devolverá estos campos adicionales usando el "validatewithip" devolverá estos campos adicionales adicionales usando el método validatewithip:

  • Propiedades
    Descripción
  • 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ó.

Validar muestras de código de correos electrónicos

  • 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 COMO Cuerda = "Tu llave secreta"
  Oscuro emailToValidate COMO Cuerda = "example@example.com"
  Oscuro responseString COMO Cuerda = ""
  Oscuro apiURL COMO Cuerda = "https://api.zerobounce.net/v1/validate?apikey=" & apiKey & "& email =" &  HttpUtility.UrlEncode(emailToValidate)
  'Descomente para usar la API opcional con búsqueda de IP
  'Dim apiURL as string = "https://api.zerobounce.net/v1/validatewithip?apikey=" & apiKey &" & email = "& HttpUtility.UrlEncode (emailToValidate) &" & ipaddress = "& HttpUtility.UrlEncode (" 99.123.12.122 ")


  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 emailToValidate = "example@example.com";
      Cuerda responseString = "";
          Cuerda apiURL = "https://api.zerobounce.net/v1/validate?apikey=" + apiKey + "& email =" +  HttpUtility.Urlencode(emailToValidate);
      
              // Descomente para usar la API opcional con búsqueda de IP
              // string apiURL = "https://api.zerobounce.net/v1/validatewithip?apikey=" + apiKey +" & email = "+ HttpUility.UrlEncode (emailToValidate); +" & ipaddress = "+ HttpUtility.UrlEncode (" 99.123.12.122 ")
      
          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';
    $ emailToValidate = 'example@example.com';
    $ IPToValidate = '99.123.12.122';
    // usa curl para hacer la solicitud
    $ url = 'https://api.zerobounce.net/v1/validate?apikey='.$ apiKey.'& email ='.Urlencode($ emailToValidate);
    // Descomente para usar la API opcional con búsqueda de IP
    // $ url = 'https://api.zerobounce.net/v1/validatewithip?apikey='.$apiKey.'&email='.urlencode($emailToValidate).'&ipaddress='.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";
            Cuerda targetURL = "https://api.zerobounce.net/v1/validate?apikey="+key+"& email ="+email;
    // Descomente para usar la API opcional con búsqueda de IP
    // String targetURL = "https://api.zerobounce.net/v1/validatewithip?apikey="+key+"&email="+email+"&ipaddress="+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/v1/validate"
    apikey = "Tu llave secreta"
    email = "example@example.com"
    ipaddress = "99.123.12.122"
    
    params = {"correo electrónico": email, "clave api": apikey}
    
    # Descomentar para usar la API opcional con búsqueda de IP
    # params ["ipaddress"] = ipaddress
    
    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 url = url(string: Cuerda(format: "https://api.zerobounce.net/v1/validate?apikey=%@&email=%@", key, email))
    dejar ip = "99.123.12.122"
    // Descomente para usar la API opcional con búsqueda de IP
    // let url = URL (string: String (formato: "https://api.zerobounce.net/v1/validatewithip?apikey=%@&email=%@&ipaddress=%@", clave, correo electrónico, 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";
    NSString *urlString = [NSString stringWithFormat:@"https://api.zerobounce.net/v1/validate?apikey=%@&email=%@", key, email];
    // NSString * urlString = [NSString stringWithFormat: @ "https://api.zerobounce.net/v1/validatewithip?apikey=%@&email=%@&ipaddress=%@", clave, correo electrónico, ip];
    // Descomente para usar la API opcional con búsqueda de 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";
        Cuerda url = "https://api.zerobounce.net/v1/validate?apikey="+key+"& email ="+email;
    // Descomente para usar la API opcional con búsqueda de IP
    // URL de cadena = "https://api.zerobounce.net/v1/validatewithip?apikey="+key+"&email="+email+"&ipaddress="+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 de punto final

Respuesta exitosa

      
    {
      "habla a":"flowerjill@aol.com",
      "estado":"válido",
      "sub_status":"",         
      "cuenta":"flowerjill",
      "dominio":"aol.com",
      "desechable":Falso,
      "tóxico":Falso,
      "primer nombre":"jill",
      "apellido":"stein",
      "género":"hembra",
      "ubicación":nulo,
      "fecha de creación":nulo,
      "procesado en":"2017-04-01 02:48:02.592"
     }
    

Respuesta exitosa con IP

      
    {
      "habla a":"flowerjill@aol.com",
      "estado":"válido",
      "sub_status":"", 
      "cuenta":"flowerjill",
      "dominio":"aol.com",
      "desechable":Falso,
      "tóxico":Falso,
      "primer nombre":"jill",
      "apellido":"stein",
      "género":"hembra",
      "ubicación":nulo,
      "país":"Estados Unidos",
      "región":"Florida",
      "ciudad":"West Palm Beach",
      "código postal":"33401",
      "fecha de creación":nulo,
      "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"}