Inicio rápido de API
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": []
}
]
}
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ámetroDescripción
- clave apiSu clave API, que se encuentra en su cuenta.
Obtener muestras de código de saldo de crédito
'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.
Si desea llamar a la API desde su navegador para probarla, todo lo que tiene que hacer es reemplazar la CLAVE API con su clave:
https://api.zerobounce.net/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}
GET / v2 / getapiusage
URL de API: https://bulkapi.zerobounce.net/v2/getapiusage
Parámetros URL
- ParámetroDescripción
- clave apiSu clave API, que se encuentra en su cuenta.
- fecha de inicioThe start date of when you want to view API usage. (format: yyyy/mm/dd)
- fecha finalThe end date of when you want to view API usage. (format: yyyy/mm/dd)
- https://api.zerobounce.net/v2/getapiusage?api_key=your-api-key&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ámetroDescripción
- TotalNúmero total de veces que se ha llamado a la API
- ESTADO_VÁLIDOTotal de direcciones de correo electrónico válidas devueltas por la API
- ESTADO_INVÁLIDOTotal de direcciones de correo electrónico no válidas devueltas por la API
- STATUS_CATCH_ALLTotal de direcciones de correo electrónico generales devueltas por la API
- STATUS_DO_NOT_MAILTotal de direcciones de correo electrónico no enviadas por la API
- STATUS_SPAMTRAPTotal de direcciones de correo electrónico de spam devueltas por la API
- ESTADO DESCONOCIDOTotal de direcciones de correo electrónico desconocidas devueltas por la API
- sub_status_toxicNúmero total de veces que la API tiene un estado secundario de "tóxico"
- sub_status_disposableNúmero total de veces que la API tiene un estado secundario de "desechable"
- sub_status_role_basedNúmero total de veces que la API tiene un sub estado de "role_based"
- sub_status_possible_trapNúmero total de veces que la API tiene un estado secundario de "posible_trap"
- sub_status_global_suppressionNúmero total de veces que la API tiene un estado secundario de "global_suppression"
- sub_status_timeout_exceededNúmero total de veces que la API tiene un estado secundario de "timeout_exceeded"
- sub_status_mail_server_temporary_errorNúmero total de veces que la API tiene un subestado de "mail_server_temporary_error"
- sub_status_mail_server_did_not_respondNúmero total de veces que la API tiene un estado secundario de "mail_server_did_not_respond"
- sub_status_greylistedNúmero total de veces que la API tiene un estado secundario de "lista gris"
- sub_status_antispam_systemNúmero total de veces que la API tiene un estado secundario de "antispam_system"
- sub_status_does_not_accept_mailNúmero total de veces que la API tiene un estado secundario de "does_not_accept_mail"
- sub_status_exception_occurredNúmero total de veces que la API tiene un estado secundario de "excepción_currida"
- sub_status_failed_syntax_checkNúmero total de veces que la API tiene un estado secundario de "failure_syntax_check"
- sub_status_mailbox_not_foundNúmero total de veces que la API tiene un estado secundario de "buzón_no_encontrado"
- sub_status_unroutable_ip_addressNúmero total de veces que la API tiene un estado secundario de "unroutable_ip_address"
- sub_status_possible_typoNúmero total de veces que la API tiene un estado secundario de "possible_typo"
- sub_status_no_dns_entriesNúmero total de veces que la API tiene un estado secundario de "no_dns_entries"
- sub_status_role_based_catch_allTotal basado en roles para capturar todos, la API tiene un estado secundario de "role_based_catch_all"
- sub_status_mailbox_quota_exceededNúmero total de veces que la API tiene un estado secundario de "buzón_cuota_excedida"
- sub_status_forcible_disconnectTotal de desconexiones forzadas, la API tiene un estado secundario de "forcible_disconnect"
- sub_status_failed_smtp_connectionTotal de conexiones SMTP fallidas, la API tiene un estado secundario de "failure_smtp_connection"
- fecha de inicioStart date of query. (format: yyyy/mm/dd)
- fecha finalEnd date of query. (format: yyyy/mm/dd)
Obtenga ejemplos de código de uso de API
'Las bibliotecas y envoltorios API completos se pueden encontrar aquí:
' https://www.zerobounce.net/docs/zerobounce-api-wrappers/#api_wrappers__v2__dot_net
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"}
Below you will find the instructions on how to use our API, it's very easy to use and requires SSL. The API requires that you have an active credit balance and will never consume a credit for any unknown result. This endpoint can be called asynchronously and is currently not rate limited.
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
Below you will find the instructions on how to use our API, it's very easy to use and requires SSL. The API requires that you have an active credit balance and will never consume a credit for any unknown result. This endpoint can be called asynchronously and is currently not rate limited.
Parámetros URL
- ParámetroDescripción
- CORREO ELECTRÓNICOLa dirección de correo electrónico que desea validar
- dirección ipLa dirección IP desde la que se registró el correo electrónico (puede estar en blanco, pero se requiere un parámetro)
- clave apiSu 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:
'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
- PropiedadesDescripción
- habla aLa 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]
- cuentaLa parte de la dirección de correo electrónico antes del símbolo "@".
- DominioLa parte de la dirección de correo electrónico despus del símbolo "@".
- querías decirSolución sugerente para un error tipográfico de correo electrónico
- domain_age_daysAntigü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_recordEl registro MX preferido del dominio.
- smtp_providerEl proveedor SMTP del correo electrónico o [nulo] [BETA].
- nombre de pilaEl primer nombre del propietario del correo electrónico cuando esté disponible o [nulo].
- apellidoEl apellido del propietario del correo electrónico cuando esté disponible o [nulo].
- géneroEl género del propietario del correo electrónico cuando está disponible o [nulo].
- ciudadThe city of the IP passed in or [null]
- regiónThe region/state of the IP passed in or [null]
- código postalThe zipcode of the IP passed in or [null]
- paísThe country of the IP passed in or [null]
- procesado enLa hora UTC en que se validó el correo electrónico.
This endpoint allows you to send us batches up to 100 emails at a time. It is rate limited to 5 uses per minute, if you exceed the rate limit, you will be blocked for 10 minutes. If you're looking to do single email validations, please use our single email validator endpoint.
If you're looking to upload files with emails greater than 100 at a time without any rate limiting restrictions, please use our Bulk File Management Endpoints which also includes anti-greylisting as an added benefit.
This endpoint can take up to 70 seconds to return the results of the entire batch. We currently don't have an SDK for this endpoint, but SDK's are available for our other endpoints.
- POST /v2/validatebatch
URL de API: https://bulkapi.zerobounce.net/v2/validatebatch
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ámetroDescripción
- CORREO ELECTRÓNICOLa dirección de correo electrónico que desea validar
- email_batch[Array of Objects], Format:{"email_address": "valid@example.com","ip_address": "1.1.1.1"}
Example Post Request
{
"clave api":"Su clave API",
"email_batch":[
{"email_address": "valid@example.com","dirección ip": "1.1.1.1"},
{"email_address": "invalid@example.com","dirección ip": "1.1.1.1"},
{"email_address": "disposable@example.com","dirección ip": nulo}
]
}
To use this endpoint, use the code examples below for the desired language:
Oscuro apiURL = "https://bulkapi.zerobounce.net/v2/validatebatch"
Oscuro apiKey = "Su clave API"
Oscuro formData = "{""api_key"":""" & apiKey & """," & vbCrLf & " " & """email_batch"":[" & vbCrLf &
"{""email_address"": ""valid@example.com"",""ip_address"": ""1.1.1.1""}," & vbCrLf &
"{""email_address"": ""invalid@example.com"",""ip_address"": ""1.1.1.1""}," & vbCrLf &
"{""email_address"": ""disposable@example.com"",""ip_address"": null}" & vbCrLf & "]" & vbCrLf & "}"
Oscuro request COMO HttpWebRequest = CType(WebRequest.Create(apiURL), HttpWebRequest)
request.Method = "ENVIAR"
request.ContentType = "application/json"
request.ContentLength = formData.Length
Oscuro formLookupDataBytes COMO Byte() = Encoding.UTF8.GetBytes(formData)
Utilizando postStream COMO Corriente = request.GetRequestStream()
postStream.Escribir(formLookupDataBytes, 0, formLookupDataBytes.Length)
Fin Utilizando
Utilizando response = CType(request.GetResponse(), HttpWebResponse)
Utilizando sr = NUEVO StreamReader(response.GetResponseStream())
Oscuro responseString = sr.ReadToEnd()
Fin Utilizando
Fin Utilizando
var apiURL = "https://bulkapi.zerobounce.net/v2/validatebatch";
var apiKey = "Su clave API";
var formData = "{"api_key":"" + apiKey + "", " +
""email_batch":[" +
"{"email_address": "valid@example.com","ip_address": "1.1.1.1"}," +
"{"email_address": "invalid@example.com","ip_address": "1.1.1.1"}," +
"{"email_address": "disposable@example.com","ip_address": null}]}";
Httpwebrequest request = (HttpWebRequest)WebRequest.crear(apiURL);
request.Method = "ENVIAR";
request.ContentType = "application/json";
request.ContentLength = formData.Length;
byte[] formLookupDataBytes = UTF8Encoding.UTF8.GetBytes(formData);
Utilizando (Corriente postStream = request.GetRequestStream())
{
postStream.Escribir(formLookupDataBytes, 0, formLookupDataBytes.Length);
}
Utilizando (var response = (HttpWebResponse)request.Obtener una respuesta())
{
Utilizando (var sr = NUEVO Lector de corriente(response.Getresponsestream()))
{
var responseString = sr.Readtoend();
}
}
<?php
$ curl = curl_init();
curl_setopt_array($ curl, formación(
CURLOPT_URL => "https://bulkapi.zerobounce.net/v2/validatebatch",
CURLOPT_RETURNTRANSFER => Cierto,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 0,
CURLOPT_FOLLOWLOCATION => Cierto,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "ENVIAR",
CURLOPT_POSTFIELDS =>"{"clave api":"Your API KEY", "email_batch":[{"email_address": "valid@example.com","dirección ip": "1.1.1.1"},{"email_address": "invalid@example.com","dirección ip": "1.1.1.1"},{"email_address": "disposable@example.com","dirección ip": null}]}",
CURLOPT_HTTPHEADER => formación(
"x-token: eyJ0eXAiOiJKV1QiLCJhbGciOiJIUzI1NiJ9.eyJ1c2VybmFtZSI6ImhlbnJ5QHplcm9ib3VuY2UubmV0IiwiZXhwIjoxNTk1NzEzNTI1fQ.nzOT-bJ8_tvnrNy3t1DeIDNMXxS-YEvlCbZye-9vpr4",
"Content-Type: application/json",
"Cookie: __cfduid=db977bdba3d06a8c9c19b45a92d6221b41572452483"
),
));
$ respuesta = curl_exec($ curl);
curl_close($ curl);
eco $ respuesta;
?>
importar http.client
importar mimetypes
conn = http.client.HTTPSConnection("bulkapi.zerobounce.net")
payload = '{
"clave api":"Su clave API",
"email_batch":[
{
"email_address": "valid@example.com",
"dirección ip": "1.1.1.1"
},
{
"email_address": "invalid@example.com",
"dirección ip": "1.1.1.1"
},
{
"email_address": "disposable@example.com",
"dirección ip": null
}
]
}'
headers = {
'x-token': 'eyJ0eXAiOiJKV1QiLCJhbGciOiJIUzI1NiJ9.eyJ1c2VybmFtZSI6ImhlbnJ5QHplcm9ib3VuY2UubmV0IiwiZXhwIjoxNTk1NzEzNTI1fQ.nzOT-bJ8_tvnrNy3t1DeIDNMXxS-YEvlCbZye-9vpr4',
'tipo de contenido': 'application/json',
'Cookie': '__cfduid=db977bdba3d06a8c9c19b45a92d6221b41572452483'
}
conn.request("ENVIAR", "/v2/validatebatch", payload, headers)
res = conn.getresponse()
data = res.read()
impresión(data.decode("utf- 8"))
importar Fundación
var semaphore = DispatchSemaphore (value: 0)
dejar parameters = "{"api_key":"Your API KEY", "email_batch":[{"email_address": "valid@example.com","ip_address": "1.1.1.1"},{"email_address": "invalid@example.com","ip_address": "1.1.1.1"},{"email_address": "disposable@example.com","ip_address": null}]}"
dejar postData = parameters.Datos(using: .utf8)
var request = Solicitud de url(url: url(string: "https://bulkapi.zerobounce.net/v2/validatebatch")!,timeoutInterval: Double.infinity)
request.addValue("eyJ0eXAiOiJKV1QiLCJhbGciOiJIUzI1NiJ9.eyJ1c2VybmFtZSI6ImhlbnJ5QHplcm9ib3VuY2UubmV0IiwiZXhwIjoxNTk1NzEzNTI1fQ.nzOT-bJ8_tvnrNy3t1DeIDNMXxS-YEvlCbZye-9vpr4", forHTTPHeaderField: "x-token")
request.addValue("application/json", forHTTPHeaderField: "Tipo de contenido")
request.addValue("__cfduid=db977bdba3d06a8c9c19b45a92d6221b41572452483", forHTTPHeaderField: "Cookie")
request.httpMethod = "ENVIAR"
request.httpBody = postData
dejar task = Sesión.shared.tarea de datos(with: request) { data, response, error en
guard dejar data = data más {
impresión(Cuerda(describing: error))
Regreso
}
impresión(Cuerda(data: data, encoding: .utf8)!)
semaphore.signal()
}
task.currículum()
semaphore.wait()
curl --location --request POST 'https://bulkapi.zerobounce.net/v2/validatebatch' --header 'x-token: eyJ0eXAiOiJKV1QiLCJhbGciOiJIUzI1NiJ9.eyJ1c2VybmFtZSI6ImhlbnJ5QHplcm9ib3VuY2UubmV0IiwiZXhwIjoxNTk1NzEzNTI1fQ.nzOT-bJ8_tvnrNy3t1DeIDNMXxS-YEvlCbZye-9vpr4' --header 'Content-Type: application/json' --header 'Cookie: __cfduid=db977bdba3d06a8c9c19b45a92d6221b41572452483' --data-raw '{"api_key":"Your API KEY",
"email_batch":[
{"email_address": "valid@example.com","ip_address": "1.1.1.1"},
{"email_address": "invalid@example.com","ip_address": "1.1.1.1"},
{"email_address": "disposable@example.com","ip_address": null}
]
}'
Respuesta exitosa
{
"email_batch": [
{
"habla a": "valid@example.com",
"estado": "válido",
"sub_status": "",
"correo electrónico gratuito": Falso,
"querías decir": nulo,
"cuenta": nulo,
"dominio": nulo,
"domain_age_days": "9692",
"smtp_provider": "example",
"mx_found": "cierto",
"mx_record": "mx.example.com",
"primer nombre": "zero",
"apellido": "bounce",
"género": "male",
"país": nulo,
"región": nulo,
"ciudad": nulo,
"código postal": nulo,
"procesado en": "2020-09-17 17:43:11.829"
},
{
"habla a": "invalid@example.com",
"estado": "inválido",
"sub_status": "mailbox_not_found",
"correo electrónico gratuito": Falso,
"querías decir": nulo,
"cuenta": nulo,
"dominio": nulo,
"domain_age_days": "9692",
"smtp_provider": "example",
"mx_found": "cierto",
"mx_record": "mx.example.com",
"primer nombre": "zero",
"apellido": "bounce",
"género": "male",
"país": nulo,
"región": nulo,
"ciudad": nulo,
"código postal": nulo,
"procesado en": "2020-09-17 17:43:11.830"
},
{
"habla a": "disposable@example.com",
"estado": "do_not_mail",
"sub_status": "desechable",
"correo electrónico gratuito": Falso,
"querías decir": nulo,
"cuenta": nulo,
"dominio": nulo,
"domain_age_days": "9692",
"smtp_provider": "example",
"mx_found": "cierto",
"mx_record": "mx.example.com",
"primer nombre": "zero",
"apellido": "bounce",
"género": "male",
"país": nulo,
"región": nulo,
"ciudad": nulo,
"código postal": nulo,
"procesado en": "2020-09-17 17:43:11.830"
}
],
"errors": []
}
Respuesta de error
{
"email_batch": [],
"errors": [
{
"error": "Clave API no válida o su cuenta se quedó sin créditos",
"email_address": "all"
}
]
}
The API will return a JSON onject with 2 array values, "email_batch" and "errors" using the "BatchValidate" method.
The email_batch property will be an array of validated results and the errors array will be an array of errors encountered during batch vaidation, if any.
Propiedades JSON
- PropiedadesDescripción
- email_batch[Array] An Array of validated emails
- errors[Array] An Array of errors encuontered, if any
email_batch Properties
- PropiedadesDescripción
- habla aLa 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]
- cuentaLa parte de la dirección de correo electrónico antes del símbolo "@".
- DominioLa parte de la dirección de correo electrónico despus del símbolo "@".
- querías decirSolución sugerente para un error tipográfico de correo electrónico
- domain_age_daysAntigü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_recordEl registro MX preferido del dominio.
- smtp_providerEl proveedor SMTP del correo electrónico o [nulo] [BETA].
- nombre de pilaEl primer nombre del propietario del correo electrónico cuando esté disponible o [nulo].
- apellidoEl apellido del propietario del correo electrónico cuando esté disponible o [nulo].
- géneroEl género del propietario del correo electrónico cuando está disponible o [nulo].
- ciudadThe city of the IP passed in or [null]
- regiónThe region/state of the IP passed in or [null]
- código postalThe zipcode of the IP passed in or [null]
- paísThe country of the IP passed in or [null]
- procesado enLa hora UTC en que se validó el correo electrónico.
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
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.
- spamtrap - These emails are believed to be spamtraps and should not be mailed. We have technology in place to determine if certain emails should be classified as spamtrap. We don't know all the spamtrap email addresses, but we do know a lot of them. Read our Guide to Spam Traps to learn more.
- 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.
- 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.
- 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.
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).
Estos son los elementos que cambiaron entre v1 y v2.
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)
El estado "DoNotMail" se cambió a "do_not_mail"
Todos los estados ahora están en minúsculas, en lugar de mayúsculas y minúsculas.
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].
Agregamos una propiedad domain_age_days para informarle la antigüedad del dominio [prevención de fraude].
Agregamos la propiedad smtp_provider para el dominio de correo electrónico, esta característica está en beta.
Agregamos la propiedad mx_found, para informarle si el dominio tiene un registro MX
Agregamos la propiedad mx_record, para indicarle el registro MX preferido del dominio.
Agregamos la propiedad did_you_mean, que se completará si se detecta un error tipográfico con una corrección sugerida.
La propiedad apiKey se cambió a api_key
La propiedad IPAddress se cambió a ip_address
El método validatewithip fue eliminado, ahora es parte del método validar
Se eliminó la propiedad de ubicación (no se estaba usando)
La propiedad creation_date se eliminó (no se estaba usando)
la propiedad processedat ahora se procesa_at
Agregamos un nuevo sub_status llamado "role_based_catch_all"
Agregamos tres nuevas API, sendfile, filestatus y getfile para la validación masiva de correo electrónico.
Uso de API recomendado
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.
There is no restriction on file size, number of emails, or number of files you can submit using this endpoint, as long as you have the credits in your account to cover the number of emails in submitted in the file, it will be accepted.
POST / v2 / sendfile
URL de API: https://bulkapi.zerobounce.net/v2/sendfile
Parámetros URL
- ParámetroDescripción
- expedientearchivo csv o txt. Contenido de la matriz de bytes para el archivo enviado. El encabezado del contenido es tipo "text / csv".
- clave apiSu clave API, que se encuentra en su cuenta. (Necesario)
- return_urlLa URL se utilizará para devolver la llamada cuando se complete la validación. (Opcional)
- email_address_columnEl índice de columna de la dirección de correo electrónico en el archivo. El índice comienza desde 1. (Necesario)
- nombre_columna_nombreEl índice de columna de la columna de nombre. (Opcional)
- apellido_columnaEl índice de columna de la columna de apellido. (Opcional)
- género_columnaEl índice de columna de la columna de género. (Opcional)
- ip_address_columnLa dirección IP desde la que se registró el correo electrónico. (Opcional)
- has_header_rowSi 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
'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 => "------WebKitFormBoundary7MA4YWxkTrZu0gWContent-Disposition: form-data; name="clave api"replacewithyours------WebKitFormBoundary7MA4YWxkTrZu0gWContent-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, "------WebKitFormBoundary7MA4YWxkTrZu0gWContent-Disposition: form-data; name="api_key"replacewithyours------WebKitFormBoundary7MA4YWxkTrZu0gWContent-Disposition: 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 = "------WebKitFormBoundary7MA4YWxkTrZu0gWContent-Disposition: form-data; name="api_key"replacewithyours------WebKitFormBoundary7MA4YWxkTrZu0gWContent-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 += "Content-Type: (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[@"nombre"], param[@"nombre del archivo"]];
[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[@"nombre"]];
[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"
]
}
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ámetroDescripción
- clave apiSu clave API, que se encuentra en su cuenta.
- file_idEl 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
'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"
}
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ámetroDescripción
- clave apiSu clave API, que se encuentra en su cuenta.
- file_idEl 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
'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"
}
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ámetroDescripción
- clave apiSu clave API, que se encuentra en su cuenta.
- file_idEl ID de archivo devuelto al llamar a la API sendfile.
Eliminar muestras de código de archivo
'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".
}