AI Scoring API: Datei senden

Mit der Sendfile-API für die Bewertung kann ein Benutzer eine Datei für die Bewertung von Massen-E-Mails senden. Der Inhaltstyp muss mehrteilig / Formulardaten sein. Weitere Informationen finden Sie im C # -Beispiel.

POST / V2 / SCORING / SENDFILE

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

URL-Parameter

  • Parameter
    Erforderlich / Optional
    Beschreibung
  • datei
    Erforderlich
    Die CSV- oder TXT-Datei. Byte-Array-Inhalt für die übermittelte Datei. Der Header des Inhalts ist der Typ "text / csv".
  • api-schlüssel
    Erforderlich
    Ihr API-Schlüssel befindet sich in Ihrem Konto
  • email_address_column
    Erforderlich
    Der Spaltenindex der E-Mail-Adresse in der Datei. Der Index beginnt bei 1
  • return_url
    Wahlweise
    Die URL wird als Rückruf verwendet, wenn der Bewertungsdienst abgeschlossen ist
  • has_header_row
    Wahlweise
    Wenn die erste Zeile aus der übermittelten Datei eine Kopfzeile ist. Richtig oder falsch

Wenn während der Anforderung der Sendedatei in den mehrteiligen Formulardaten eine return_url angegeben wurde, werden die folgenden Daten nach Abschluss des Validierungsprozesses an die URL gesendet.


                {
                  file_id": "aaaaaaaa-zzzz-xxxx-yyyy-5003727fffff",
                  "dateiname": "Ihr Dateiname.csv", 
                  "datum des hochladens": "10/20/2018 4:35: 58 PM" 
                }
                

Senden Sie Dateicode-Beispiele

  • Visuelle Basis
  • C#
  • PHP
  • Java
  • Python
  • Schnell
  • Ziel c
  • Android Java
      
'Datei-Beispiel in VB.net senden

Öffentlichkeit Klasse SendFileStatus
   Öffentlichkeit Eigentum success WIE Boolesch
   Öffentlichkeit Eigentum message WIE Zeichenfolge
   Öffentlichkeit Eigentum file_name WIE Zeichenfolge
   Öffentlichkeit Eigentum file_id WIE Zeichenfolge
ENDE Klasse

Privat Freigegeben Sub SendFileAPITest()
   Dim fileFullPath WIE Zeichenfolge = $"vollständiger dateipfad einer csv- oder txt-datei"  'erforderlich
   Dim apiKey WIE Zeichenfolge = "hier durch deinen api-schlüssel ersetzen"              'erforderlich
   Dim emailAddressColumn WIE Ganze Zahl = 2  'erforderlich
   Dim ipAddressColumn WIE Ganze Zahl? = 11   ' optional
   Dim hasHeaderRow WIE Boolesch? = Wahr    ' optional
   Dim returnUrl WIE Zeichenfolge = Nichts      ' optional

   VERSUCHEN
       Dim sendFileStatus WIE SendFileStatus = SendFile(fileFullPath, apiKey, emailAddressColumn, ipAddressColumn, hasHeaderRow, returnUrl).Result
       Console.Schreiben(JsonConvert.SerializeObject(sendFileStatus, Formatting.Indented))
   Fang ex WIE Exception
       Console.Schreiben(ex.InnerException.Message)
   ENDE VERSUCHEN

   Console.ReadKey()
ENDE Sub

Öffentlichkeit Freigegeben Async Funktion SendFile(Byval fileFullPath WIE Zeichenfolge, 
                                     Byval apiKey WIE Zeichenfolge, 
                                     Byval emailAddressColumn WIE Ganze Zahl, 
                                     Byval Wahlweise ipAddressColumn WIE Ganze Zahl? = Nichts, 
                                     Byval Wahlweise hasHeaderRow WIE Boolesch? = Nichts, 
                                     Byval Wahlweise returnUrl WIE Zeichenfolge = Nichts) WIE Task(Von SendFileStatus)

   OB Zeichenfolge.IsNullOrEmpty(fileFullPath) Dann Werfen NEU Exception("Fehler: fileFullPath ist erforderlich")
   OB Zeichenfolge.IsNullOrEmpty(apiKey) Dann Werfen NEU Exception("Fehler: apiKey ist erforderlich")
   Dim fi = NEU FileInfo(fileFullPath)
   Dim fileContents = File.ReadAllBytes(fi.FullName)
   Dim fileName = fi.Name
   Dim uri WIE Uri = NEU Uri("https://bulkapi.zerobounce.net/v2/scoring/sendfile")

   Verwenden client = NEU HttpClient()

       Verwenden request = NEU HttpRequestMessage(HttpMethod.Post, uri)
           Dim multiPartContent WIE MultipartFormDataContent = NEU MultipartFormDataContent()
           Dim byteArrayContent WIE ByteArrayContent = NEU ByteArrayContent(fileContents)
           byteArrayContent.Headers.Add("Inhaltstyp", "text / csv")
           multiPartContent.Add(byteArrayContent, "datei", fileName)
           multiPartContent.Add(NEU StringContent(apiKey), "api-schlüssel")
           multiPartContent.Add(NEU StringContent(emailAddressColumn.ToString()), "email_address_column")
           OB ipAddressColumn Ist nicht Nichts Dann multiPartContent.Add(NEU StringContent(ipAddressColumn.ToString()), "ip_address_column")
           OB hasHeaderRow Ist nicht Nichts Dann multiPartContent.Add(NEU StringContent(OB((hasHeaderRow = Wahr), "wahr", "falsch")), "has_header_row")
           OB returnUrl Ist nicht Nichts Dann multiPartContent.Add(NEU StringContent(returnUrl.ToString()), "return_url")
           request.Content = multiPartContent

           Verwenden response = Await client.SendAsync(request, HttpCompletionOption.ResponseContentRead, CancellationToken.None).ConfigureAwait(Falsch)
               Dim content = Await response.Content.ReadAsStringAsync()

               OB response.IsSuccessStatusCode = Falsch Dann
                   Dim error WIE Zeichenfolge = $"StatusCode = {Cint(response.StatusCode)}, Content = {content}"
                   Werfen NEU Exception(error)
               ENDE OB

               Rückkehr JsonConvert.DeserializeObject(Von SendFileStatus)(content)
           ENDE Verwenden
       ENDE Verwenden
   ENDE Verwenden
ENDE Funktion
   

// Dateiprobe in C # senden

Öffentlichkeit Klasse Sendfilestatus
{
   Öffentlichkeit bool success { bekommen; einstellen; }
   Öffentlichkeit Zeichenfolge message { bekommen; einstellen; }
   Öffentlichkeit Zeichenfolge file_name { bekommen; einstellen; }
   Öffentlichkeit Zeichenfolge file_id { bekommen; einstellen; }
}

Privat statisch leere Sendfileapitest()
{
   Zeichenfolge fileFullPath = $"vollständiger dateipfad einer csv- oder txt-datei";  //erforderlich
   Zeichenfolge apiKey = "hier durch deinen api-schlüssel ersetzen";  //erforderlich       
   int emailAddressColumn = 2;  //erforderlich
   int? ipAddressColumn = 11;  //Optional
   bool? hasHeaderRow = Wahr;  //Optional
   Zeichenfolge returnUrl = null;  //Optional

   VERSUCHEN
   {
       Sendfilestatus sendFileStatus = Datei senden(fileFullPath, apiKey, emailAddressColumn, ipAddressColumn, hasHeaderRow, returnUrl).Result;
       Console.Schreiben(JsonConvert.Serializeobject(sendFileStatus, Formatting.Indented));
   }
   Fang (Ausnahme ex)
   {
       Console.Schreiben(ex.InnerException.Message);
   }

   Console.Schlüssel einlesen();
}

Öffentlichkeit statisch asynchron Task<SendFileStatus> Datei senden(Zeichenfolge fileFullPath, Zeichenfolge apiKey, int emailAddressColumn, 
                                           int? ipAddressColumn = null, bool? hasHeaderRow = null, Zeichenfolge returnUrl = null)
{
   OB (Zeichenfolge.Isnullorempty(fileFullPath))
       Werfen NEU Ausnahme("Fehler: fileFullPath ist erforderlich");
   OB (Zeichenfolge.Isnullorempty(apiKey))
       Werfen NEU Ausnahme("Fehler: apiKey ist erforderlich");

   var fi = NEU Dateiinformation(fileFullPath);
   var fileContents = File.Readallbytes(fi.FullName);
   var fileName = fi.Name;

   Uri uri = NEU Uri(@"https://bulkapi.zerobounce.net/v2/scoring/sendfile");

   Verwenden (var client = NEU Httpclient())
   Verwenden (var request = NEU Httprequestmessage(HttpMethod.Post, uri))
   {
       Multipartformdatacontent multiPartContent = NEU Multipartformdatacontent();
       Bytearray-Inhalt byteArrayContent = NEU Bytearray-Inhalt(fileContents);
       byteArrayContent.Headers.Hinzufügen("Inhaltstyp", "text / csv");
       multiPartContent.Hinzufügen(byteArrayContent, "datei", fileName);
       multiPartContent.Hinzufügen(NEU String-Inhalt(apiKey), "api-schlüssel");
       multiPartContent.Hinzufügen(NEU String-Inhalt(emailAddressColumn.Tostring()), "email_address_column");
       OB (ipAddressColumn != null)
           multiPartContent.Hinzufügen(NEU String-Inhalt(ipAddressColumn.Tostring()), "ip_address_column");
       OB (hasHeaderRow != null)
           multiPartContent.Hinzufügen(NEU String-Inhalt((hasHeaderRow == Wahr) ? "wahr" : "falsch"), "has_header_row");
       OB (returnUrl != null)
           multiPartContent.Hinzufügen(NEU String-Inhalt(returnUrl.Tostring()), "return_url");

       request.Content = multiPartContent;

       Verwenden (var response = erwarten client.Sendasync(request, HttpCompletionOption.ResponseContentRead, CancellationToken.None).Configurewawait(Falsch))
       {
           var content = erwarten response.Content.Readasstringasync();

           OB (response.IsSuccessStatusCode == Falsch)
           {
               var error = $"StatusCode = {(int) response.StatusCode}, Content = {content}";
               Werfen NEU Ausnahme(error);
           }

           Rückkehr JsonConvert.Objekt deserialisieren<Sendfilestatus>(content);
       }
   }
}
   

 <?php

$ curl = curl_init();

curl_setopt_array($ curl, array(
 CURLOPT_URL => "https://bulkapi.zerobounce.net/v2/scoring/sendfile",
 CURLOPT_RETURNTRANSFER => Wahr,
 CURLOPT_ENCODING => "",
 CURLOPT_MAXREDIRS => 10,
 CURLOPT_TIMEOUT => 30,
 CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
 CURLOPT_CUSTOMREQUEST => "POST",
 CURLOPT_POSTFIELDS => "------ WebKitFormBoundary7MA4YWxkTrZu0gW Inhaltsdisposition: Formulardaten; name ="api-schlüssel"Ersetzen durch Ihre ------ WebKitFormBoundary7MA4YWxkTrZu0gW Inhaltsdisposition: Formulardaten; Name ="email_address_column"Ersetzen durch Ihre ------ WebKitFormBoundary7MA4YWxkTrZu0gW--",
 CURLOPT_HTTPHEADER => array(
   Postboten-Token: fae6714d-dc09- 4 e08-b50d-c97030603b61,
   "cache-kontrolle: kein cache",
   "Inhaltstyp: mehrteilig / Formulardaten; Grenze = ---- WebKitFormBoundary7MA4YWxkTrZu0gW"
 ),
));

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

curl_close($ curl);

OB ($ err) {
 echo "Curl-Fehler #:" . $ err;
} sonst {
 echo $ antwort;
}
?>
   

 Okhttpclient client = NEU Okhttpclient();

 Medientyp mediaType = Medientyp.analysieren("mehrteilige / Formulardaten; Grenze = ---- WebKitFormBoundary7MA4YWxkTrZu0gW");
 Anfrage body = Anfrage.erstellen(mediaType, "------Webkitformboundary7ma4ywxktrzu0gw
Inhalt-Anordnung: form-data; name="api-schlüssel"

replacewithyours
------Webkitformboundary7ma4ywxktrzu0gw
Inhalt-Anordnung: form-data; name="email_address_column"

replacewithyours
------Webkitformboundary7ma4ywxktrzu0gw--");
 Anfrage request = NEU Anfrage.Baumeister()
   .url("https://bulkapi.zerobounce.net/v2/scoring/sendfile")
   .post(body)
   .Addheader("Inhaltstyp", "mehrteilige / Formulardaten; Grenze = ---- WebKitFormBoundary7MA4YWxkTrZu0gW")
   .Addheader("cache-kontrolle", "kein cache")
   .Addheader("Postbote-Token", 25 d608ba- 6 cb5- 4 c8c- 88 d7-d47276c67d8e)
   .bauen();
 
 Antwort response = client.neuer Anruf(request).ausführen();
   

 einführen http.client

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

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

replacewithyours
------WebKitFormBoundary7MA4YWxkTrZu0gW--"
 
 headers = {
     'inhaltstyp': "mehrteilige / Formulardaten; Grenze = ---- WebKitFormBoundary7MA4YWxkTrZu0gW",
     'cache-kontrolle': "kein cache",
     "Postbote-Token": bc455eda- 9884-417 e-b16f- 3 a5fef3f7540
     }
 
 conn.request("POST", "v2, sendfile", payload, headers)
 
 res = conn.getresponse()
 data = res.read()
 
 drucken(data.decode("utf- 8"))
   
   

 einführen Stiftung

 lassen headers = [
   "Inhaltstyp": "mehrteilige / Formulardaten; Grenze = ---- WebKitFormBoundary7MA4YWxkTrZu0gW",
   "cache-kontrolle": "kein cache",
   "Postbote-Token": 2 f68fcc3-d9b6- 458 b-b613- 56 f6a03e6617
 ]
 lassen parameters = [
   [
     "name": "api-schlüssel",
     "wert": "ersetzen durch ihre"
   ],
   [
     "name": "email_address_column",
     "wert": "ersetzen durch ihre"
   ]
 ]
 
 lassen boundary = "---- WebKitFormBoundary7MA4YWxkTrZu0gW"
 
 var body = ""
 var error: Nserror? = null
 zum param im parameters {
   lassen paramName = param["name"]!
   body += "--(boundary)
"
   body += "Inhaltsdisposition: Formulardaten; Name ="(paramName)""
   OB lassen filename = param["Dateiname"] {
     lassen contentType = param["Inhaltstyp"]!
     lassen fileContent = Zeichenfolge(contentsOfFile: filename, encoding: Zeichenfolge.Codierung.utf8)
     OB (error != null) {
       drucken(error)
     }
     body += "; dateiname ="(filename)"
"
     body += "Inhalt-Art: (contentType)

"
     body += fileContent
   } sonst OB lassen paramValue = param["wert"] {
     body += "

(paramValue)"
   }
 }
 
 lassen request = Nsmutableurlrequest(url: NSURL(string: "https://bulkapi.zerobounce.net/v2/scoring/sendfile")! WIE url, 
                                       cachePolicy: .useProtocolCachePolicy,
                                       timeoutInterval: 10.0)
 request.httpMethod = "POST"
 request.allHTTPHeaderFields = headers
 request.httpBody = postData WIE Daten
 
 lassen session = Urlsession.shared
 lassen dataTask = session.Datenaufgabe(with: request WIE URL-Anfrage, completionHandler: { (data, response, error) -> leere im
   OB (error != null) {
     drucken(error)
   } sonst {
     lassen httpResponse = response WIE? Httpurlresponse
     drucken(httpResponse)
   }
 })
 
 dataTask.fortsetzen()
   

// Bitte wählen Sie die Sprache VB oder C # für den Import von Send Sample #  <Foundation/Foundation.h>

NSDictionary *headers = @{ @"inhaltstyp": @ "multipart / form-data; border = ---- WebKitFormBoundary7MA4YWxkTrZu0gW",
                           @ "cache-kontrolle": @ "kein cache",
                           @ "Postman-Token": @ "92 c5b06e- 624 f- 44 e5-bd86-f537bc6cef67" };
NSArray *parameters = @[ @{ @"name": @"api-schlüssel", @"wert": @ "ersetzen durch ihre" },
                         @{ @"name": @ "email_address_column", @"wert": @ "ersetzen durch ihre" } ];
NSString *boundary = @ "---- WebKitFormBoundary7MA4YWxkTrZu0gW";

NSError *error;
NSMutableString *body = [NSMutableString string];
zum (NSDictionary *param im parameters) {
   [body appendFormat:@"--%@
", boundary];
   OB (param[@"Dateiname"]) {
       [body appendFormat:@ "Inhaltsdisposition: Formulardaten; Name ="%@ "; dateiname ="%@"
", param [@"name"], param [@"fileName"]];
       [body appendFormat:@"Content-Type: %@

", param [@"contentType"]];
       [body appendFormat:@"%@", [NSString stringWithContentsOfFile:param[@"Dateiname"] encoding:NSUTF8StringEncoding error:&error]];
       OB (error) {
           Nslog(@"%@", error);
       }
   } sonst {
       [body appendFormat:@ "Inhaltsdisposition: Formulardaten; Name ="%@"

", param [@"name"]];
       [body appendFormat:@"%@", param[@"wert"]];
   }
}
[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:@"POST"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                           completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                               OB (error) {
                                                   Nslog(@"%@", error);
                                               } sonst {
                                                   NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                   Nslog(@"%@", httpResponse);
                                               }
                                           }];
[dataTask resume];
   

//N/A
   

Endpunktantwort

Erfolgreiche Antwort

      
{
 "erfolg": Wahr,
 "botschaft": "Datei akzeptiert",
 "dateiname": "Ihr Dateiname.csv",
 "file_id": "aaaaaaaa-zzzz-xxxx-yyyy- 5003727 fffff"
}
   

Fehlerantwort

      
   {
     "erfolg": Falsch,
     "botschaft": [
         "Fehlermeldungen"
     ]
 }