API de puntuación de AI: Enviar archivo

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