API de puntuación de AI

La API de puntuación AI de ZeroBounce combina una amplia selección de datos con análisis estadísticos probados para calificar de forma granular el nivel de calidad de una dirección de correo electrónico. El software identifica patrones positivos y negativos de una dirección de correo electrónico y devuelve una puntuación en la que los usuarios pueden confiar cuando realizan su higiene de correo electrónico. La metodología de ZeroBounce AI se ajusta periódicamente a medida que evolucionan las tendencias del correo electrónico.

Obtenga una visión profunda de la calidad de sus clientes potenciales al aprender más sobre la actividad en línea de sus suscriptores. Con la información adicional, puede segmentar sus listas para servir mejor a sus clientes con mensajes dirigidos. Si desea segmentar aún más su lista de correo electrónico en función del Nivel de calidad, le recomendamos validar también su archivo "válido".

Punto final de gestión de archivos recomendado para la puntuación AI

Uso de punto final de administración de archivos recomendado
Uso de punto final de administración de archivos recomendado

API de puntuación de AI: Enviar archivo

/ai-scoring-api/send-file/

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

POST / V2 / PUNTUACIÓN / ENVIAR ARCHIVO

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

Parámetros URL

  • Parámetro
    Requerido / Opcional
    Descripción
  • expediente
    Necesario
    El archivo csv o txt. Contenido de la matriz de bytes para el archivo enviado. El encabezado del contenido es tipo "text / csv"
  • clave api
    Necesario
    Su clave API, que se encuentra en su cuenta
  • email_address_column
    Necesario
    El índice de columna de la dirección de correo electrónico en el archivo. El índice comienza en 1
  • return_url
    Opcional
    La URL se utilizará como devolución de llamada cuando se complete el servicio de puntuación
  • has_header_row
    Opcional
    Si la primera fila del archivo enviado es una fila de encabezado. Verdadero o falso

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


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

Enviar muestras de código de archivo

  • Visual básico
  • C#
  • PHP
  • Java
  • Pitón
  • Rápido
  • C objetivo
  • Android java
      
'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 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, 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 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/scoring/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 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
   

// 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? ipAddressColumn = 11;  //Opcional
   bool? hasHeaderRow = Cierto;  //Opcional
   Cuerda returnUrl = nulo;  //Opcional

   Tratar
   {
       Sendfilestatus sendFileStatus = Enviar archivo(fileFullPath, apiKey, emailAddressColumn, 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? 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/scoring/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.Encadenar()), "email_address_column");
       Si (ipAddressColumn != nulo)
           multiPartContent.Añadir(NUEVO Cadena de contenido(ipAddressColumn.Encadenar()), "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.Encadenar()), "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

$ curl = curl_init();

curl_setopt_array($ curl, formación(
 CURLOPT_URL => "https://bulkapi.zerobounce.net/v2/scoring/sendfile",
 CURLOPT_RETURNTRANSFER => Cierto,
 CURLOPT_ENCODING => "",
 CURLOPT_MAXREDIRS => 10,
 CURLOPT_TIMEOUT => 30,
 CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
 CURLOPT_CUSTOMREQUEST => "ENVIAR",
 CURLOPT_POSTFIELDS => "------ WebKitFormBoundary7MA4YWxkTrZu0gW Disposición de contenido: datos de formulario; nombre ="clave api"replacewithyours ------ WebKitFormBoundary7MA4YWxkTrZu0gW Content-Disposition: form-data; name ="email_address_column"replacewithyours ------ WebKitFormBoundary7MA4YWxkTrZu0gW--",
 CURLOPT_HTTPHEADER => formación(
   "Ficha de cartero: fae6714d-dc09- 4 e08-b50d-c97030603b61",
   "control de caché: sin caché",
   "content-type: multipart / form-data; boundary = ---- WebKitFormBoundary7MA4YWxkTrZu0gW"
 ),
));

$ respuesta = curl_exec($ curl);
$ err = curl_error($ curl);

curl_close($ curl);

Si ($ err) {
 eco "Error de cURL #:" . $ err;
} más {
 eco $ respuesta;
}
?>
   

 Okhttpclient client = NUEVO Okhttpclient();

 Tipo de medio mediaType = Tipo de medio.analizar gramaticalmente("multipart / form-data; boundary = ---- WebKitFormBoundary7MA4YWxkTrZu0gW");
 Cuerpo de pedido body = Cuerpo de pedido.crear(mediaType, "------Webkitformboundary7ma4ywxktrzu0gw
Contenido-Disposición: form-data; name="clave api"

replacewithyours
------Webkitformboundary7ma4ywxktrzu0gw
Contenido-Disposición: form-data; name="email_address_column"

replacewithyours
------Webkitformboundary7ma4ywxktrzu0gw--");
 Solicitud request = NUEVO Solicitud.Constructor()
   .url("https://bulkapi.zerobounce.net/v2/scoring/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();
   

 importar http.client

 conn = http.client.HTTPConnection("bulkapi, zerobounce, net")
 
 payload = "------WebKitFormBoundary7MA4YWxkTrZu0gW
Content-Disposition: form-data; name="clave api"

replacewithyours
------WebKitFormBoundary7MA4YWxkTrZu0gW
Content-Disposition: form-data; name="email_address_column"

replacewithyours
------WebKitFormBoundary7MA4YWxkTrZu0gW--"
 
 headers = {
     'tipo de contenido': "multipart / form-data; boundary = ---- WebKitFormBoundary7MA4YWxkTrZu0gW",
     'control de caché': "sin caché",
     'Ficha de cartero': "bc455eda- 9884-417 e-b16f- 3 a5fef3f7540"
     }
 
 conn.request("ENVIAR", "v2, archivo de envío", payload, headers)
 
 res = conn.getresponse()
 data = res.read()
 
 impresión(data.decode("utf- 8"))
   
   

 importar Fundación

 dejar headers = [
   "Tipo de contenido": "multipart / form-data; boundary = ---- WebKitFormBoundary7MA4YWxkTrZu0gW",
   "control de caché": "sin caché",
   "Ficha de cartero": "2 f68fcc3-d9b6- 458 b-b613- 56 f6a03e6617"
 ]
 dejar parameters = [
   [
     "nombre": "clave api",
     "valor": "replacewithyours"
   ],
   [
     "nombre": "email_address_column",
     "valor": "replacewithyours"
   ]
 ]
 
 dejar boundary = "---- WebKitFormBoundary7MA4YWxkTrZu0gW"
 
 var body = ""
 var error: Nserror? = nulo
 para param en parameters {
   dejar paramName = param["nombre"]!
   body += "--(boundary)
"
   body += "Disposición de contenido: datos de formulario; nombre ="(paramName)""
   Si dejar filename = param["nombre del archivo"] {
     dejar contentType = param["Tipo de contenido"]!
     dejar fileContent = Cuerda(contentsOfFile: filename, encoding: Cuerda.Codificación.utf8)
     Si (error != nulo) {
       impresión(error)
     }
     body += "; filename ="(filename)"
"
     body += "Contenido-Tipo: (contentType)

"
     body += fileContent
   } más Si dejar paramValue = param["valor"] {
     body += "

(paramValue)"
   }
 }
 
 dejar request = Nsmutableurlrequest(url: NSURL(string: "https://bulkapi.zerobounce.net/v2/scoring/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()
   

// Seleccione el idioma VB o C # para enviar el archivo de muestra # importar  <Foundation/Foundation.h>

NSDictionary *headers = @{ @"tipo de contenido": @ "multipart / form-data; boundary = ---- WebKitFormBoundary7MA4YWxkTrZu0gW",
                           @ "control de caché": @ "sin caché",
                           @ "Cartero-Token": @ "92 c5b06e- 624 f- 44 e5-bd86-f537bc6cef67" };
NSArray *parameters = @[ @{ @"nombre": @"clave api", @"valor": @ "replacewithyours" },
                         @{ @"nombre": @ "email_address_column", @"valor": @ "replacewithyours" } ];
NSString *boundary = @ "---- WebKitFormBoundary7MA4YWxkTrZu0gW";

NSError *error;
NSMutableString *body = [NSMutableString string];
para (NSDictionary *param en parameters) {
   [body appendFormat:@"--%@
", boundary];
   Si (param[@"nombre del archivo"]) {
       [body appendFormat:@ "Disposición de contenido: datos de formulario; nombre ="%@ "; filename ="%@"
", param [@"name"], parámetro [@"fileName"]];
       [body appendFormat:@"Content-Type: %@

", param [@"contentType"]];
       [body appendFormat:@"%@", [NSString stringWithContentsOfFile:param[@"nombre del archivo"] encoding:NSUTF8StringEncoding error:&error]];
       Si (error) {
           Nslog(@"%@", error);
       }
   } más {
       [body appendFormat:@ "Disposición de contenido: datos de formulario; nombre ="%@"

", param [@"name"]];
       [body appendFormat:@"%@", param[@"valor"]];
   }
}
[body appendFormat:@"
--%@--
", boundary];
NSData *postData = [body dataUsingEncoding:NSUTF8StringEncoding];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"https://bulkapi.zerobounce.net/v2/scoring/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];
   

//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"
     ]
 }
   

API de puntuación AI: estado del archivo

/ai-scoring-api/file-status/

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

GET / V2 / PUNTUACIÓN / FILESTATUS

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

Parámetros URL

  • Parámetro
    Requerido / Opcional
    Descripción
  • clave api
    Necesario
    Su clave API, que se encuentra en su cuenta
  • file_id
    Necesario
    El ID de archivo devuelto al llamar a la API de envío de puntaje

Si desea llamar a la API desde su navegador para probarla, todo lo que tiene que hacer es reemplazar la CLAVE DE API con su clave y la ID DE ARCHIVO con la ID del archivo devuelto desde la puntuación de sendfile

Muestras de código de estado de archivo

  • Visual básico
  • C#
  • PHP
  • Java
  • Pitón
  • Rápido
  • C objetivo
  • Android java
      
'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/scoring/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
   

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

   $ curl = curl_init();
   
   curl_setopt_array($ curl, formación(
     CURLOPT_URL => "https://bulkapi.zerobounce.net/v2/scoring/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;
   }
   ?>
   

   Okhttpclient client = NUEVO Okhttpclient();

   Solicitud request = NUEVO Solicitud.Constructor()
     .url("https://bulkapi.zerobounce.net/v2/scoring/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();
   

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

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

   #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/scoring/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];
   

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

API de puntuación de AI: Obtener archivo

/ai-scoring-api/get-file/

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

OBTENER / V2 / PUNTUACIÓN / OBTENER ARCHIVOS

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

Parámetros URL

  • Parámetro
    Requerido / Opcional
    Descripción
  • clave api
    Necesario
    Su clave API, que se encuentra en su cuenta
  • file_id
    Necesario
    El ID de archivo devuelto al llamar a la API de envío de puntaje

Obtener muestras de código de archivo

  • Visual básico
  • C#
  • PHP
  • Java
  • Pitón
  • Rápido
      
'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/scoring/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
   

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

 $ solicitud = NUEVO Solicitud HTTP();
 $ solicitud->seturl('https://bulkapi.zerobounce.net/v2/scoring/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;
 }
 ?>
   

 Okhttpclient client = NUEVO Okhttpclient();

 Solicitud request = NUEVO Solicitud.Constructor()
   .url("https://bulkapi.zerobounce.net/v2/scoring/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();
   

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

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

      
{
 "é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"
     ]
 }
   

API de puntuación de AI: Eliminar archivo

/ai-scoring-api/delete-file/

La API deletefile de puntuación elimina el archivo que se envió utilizando la API sendfile de puntuación. El archivo solo se puede eliminar cuando su estado es Completo.

POST / V2 / PUNTUACIÓN / DELETEFILE

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

Parámetros URL

  • Parámetro
    Requerido / Opcional
    Descripción
  • clave api
    Necesario
    Su clave API, que se encuentra en su cuenta
  • file_id
    Necesario
    El ID de archivo devuelto al llamar a la API de envío de puntaje

Eliminar muestras de código de archivo

  • Visual básico
  • C#
  • PHP
  • Java
  • Pitón
  • Rápido
  • C objetivo
      
'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/scoring/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
   

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

 $ curl = curl_init();
 
 curl_setopt_array($ curl, formación(
   CURLOPT_URL => "https://bulkapi.zerobounce.net/v2/scoring/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;
 }
 ?>
   

Okhttpclient client = NUEVO Okhttpclient();

Solicitud request = NUEVO Solicitud.Constructor()
 .url("https://bulkapi.zerobounce.net/v2/scoring/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();
   

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

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

#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/scoring/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".
}