#include <curl/curl.h>

int main(void) {
  CURL *curl = curl_easy_init();
  if (curl) {
    curl_easy_setopt(curl, CURLOPT_URL, "https://api.gugudata.com/imagerecognition/pdf2text?appkey={{appkey}}");
    curl_easy_setopt(curl, CURLOPT_CUSTOMREQUEST, "POST");
    curl_easy_setopt(curl, CURLOPT_FOLLOWLOCATION, 1L);
    curl_mime *mime = curl_mime_init(curl);
    curl_mimepart *part = NULL;
    part = curl_mime_addpart(mime);
    curl_mime_name(part, "pdffile");
    curl_mime_filedata(part, "localfile_path.png");
    curl_easy_setopt(curl, CURLOPT_MIMEPOST, mime);
    CURLcode res = curl_easy_perform(curl);
    (void)res;
    curl_mime_free(mime);
    curl_easy_cleanup(curl);
  }
  return 0;
}

using System;
using System.Collections.Generic;
using System.IO;
using System.Net.Http;

var client = new HttpClient();
var request = new HttpRequestMessage(HttpMethod.Post, "https://api.gugudata.com/imagerecognition/pdf2text?appkey={{appkey}}");
var content = new MultipartFormDataContent();
content.Add(new StreamContent(File.OpenRead("localfile_path.png")), "pdffile", "localfile_path.png");
request.Content = content;
var response = client.SendAsync(request).Result;
Console.WriteLine(response.Content.ReadAsStringAsync().Result);

package main

import (
  "bytes"
  "mime/multipart"
  "os"
  "path/filepath"
  "fmt"
  "io"
  "net/http"
)

func main() {
  url := "https://api.gugudata.com/imagerecognition/pdf2text?appkey={{appkey}}"
  payload := &bytes.Buffer{}
  writer := multipart.NewWriter(payload)
  file, err := os.Open("localfile_path.png")
  if err != nil {
    fmt.Println(err)
    return
  }
  defer file.Close()
  part, err := writer.CreateFormFile("pdffile", filepath.Base("localfile_path.png"))
  if err != nil {
    fmt.Println(err)
    return
  }
  if _, err = io.Copy(part, file); err != nil {
    fmt.Println(err)
    return
  }
  if err := writer.Close(); err != nil {
    fmt.Println(err)
    return
  }
  req, err := http.NewRequest("POST", url, payload)
  if err != nil {
    fmt.Println(err)
    return
  }
  req.Header.Set("Content-Type", writer.FormDataContentType())
  res, err := http.DefaultClient.Do(req)
  if err != nil {
    fmt.Println(err)
    return
  }
  defer res.Body.Close()
  body, err := io.ReadAll(res.Body)
  if err != nil {
    fmt.Println(err)
    return
  }
  fmt.Println(string(body))
}

OkHttpClient client = new OkHttpClient().newBuilder().build();
RequestBody body = new MultipartBody.Builder().setType(MultipartBody.FORM)
  .addFormDataPart("pdffile", "localfile_path.png",
    RequestBody.create(MediaType.parse("application/octet-stream"), new File("localfile_path.png")))
  .build();
Request request = new Request.Builder()
  .url("https://api.gugudata.com/imagerecognition/pdf2text?appkey={{appkey}}")
  .method("POST", body)
  .build();
Response response = client.newCall(request).execute();
System.out.println(response.body().string());

var form = new FormData();
form.append("pdffile", fileInput.files[0], "localfile_path.png");

$.ajax({
  url: "https://api.gugudata.com/imagerecognition/pdf2text?appkey={{appkey}}",
  method: "POST",
  data: form,
  processData: false,
  contentType: false
}).done(function (response) {
  console.log(response);
});

const https = require("node:https");
const fs = require("node:fs");
const path = require("node:path");

const url = "https://api.gugudata.com/imagerecognition/pdf2text?appkey={{appkey}}";
const boundary = "----GuGuDataBoundary" + Date.now().toString(16);
const formFields = {  };
const fileFields = { "pdffile": "localfile_path.png" };
const chunks = [];

for (const [name, value] of Object.entries(formFields)) {
  chunks.push(Buffer.from(`--${boundary}\r\nContent-Disposition: form-data; name="${name}"\r\n\r\n${value}\r\n`));
}

for (const [name, filePath] of Object.entries(fileFields)) {
  chunks.push(Buffer.from(`--${boundary}\r\nContent-Disposition: form-data; name="${name}"; filename="${path.basename(filePath)}"\r\nContent-Type: application/octet-stream\r\n\r\n`));
  chunks.push(fs.readFileSync(filePath));
  chunks.push(Buffer.from("\r\n"));
}
chunks.push(Buffer.from(`--${boundary}--\r\n`));
const body = Buffer.concat(chunks);

const request = https.request(url, {
  method: "POST",
  headers: {
    "Content-Type": `multipart/form-data; boundary=${boundary}`,
    "Content-Length": body.length
  }
}, handleResponse);
request.on("error", console.error);
request.write(body);
request.end();

function handleResponse(response) {
  const chunks = [];
  response.on("data", function (chunk) {
    chunks.push(chunk);
  });
  response.on("end", function () {
    console.log(Buffer.concat(chunks).toString("utf8"));
  });
}

#import <Foundation/Foundation.h>

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"https://api.gugudata.com/imagerecognition/pdf2text?appkey={{appkey}}"]];
[request setHTTPMethod:@"POST"];
NSString *boundary = [[NSUUID UUID] UUIDString];
NSMutableData *body = [NSMutableData data];
NSData *pdffileData = [NSData dataWithContentsOfFile:@"localfile_path.png"];
[body appendData:[[NSString stringWithFormat:@"--%@\r\n", boundary] dataUsingEncoding:NSUTF8StringEncoding]];
[body appendData:[@"Content-Disposition: form-data; name=\"pdffile\"; filename=\"localfile_path.png\"\r\n" dataUsingEncoding:NSUTF8StringEncoding]];
[body appendData:[@"Content-Type: application/octet-stream\r\n\r\n" dataUsingEncoding:NSUTF8StringEncoding]];
[body appendData:pdffileData];
[body appendData:[@"\r\n" dataUsingEncoding:NSUTF8StringEncoding]];
[body appendData:[[NSString stringWithFormat:@"--%@--\r\n", boundary] dataUsingEncoding:NSUTF8StringEncoding]];
[request setValue:[NSString stringWithFormat:@"multipart/form-data; boundary=%@", boundary] forHTTPHeaderField:@"Content-Type"];
[request setHTTPBody:body];
NSURLSessionDataTask *task = [[NSURLSession sharedSession] dataTaskWithRequest:request completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
  if (error) {
    NSLog(@"%@", error);
    return;
  }
  NSLog(@"%@", [[NSString alloc] initWithData:data encoding:NSUTF8StringEncoding]);
}];
[task resume];

<?php
$curl = curl_init();
curl_setopt_array($curl, array(
  CURLOPT_URL => "https://api.gugudata.com/imagerecognition/pdf2text?appkey={{appkey}}",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_FOLLOWLOCATION => true,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => array(
    "pdffile" => new CURLFile("localfile_path.png", "application/octet-stream", "localfile_path.png"),
  ),
));
$response = curl_exec($curl);
curl_close($curl);
echo $response;

import requests

url = "https://api.gugudata.com/imagerecognition/pdf2text?appkey={{appkey}}"
payload = {  }
files = {
    "pdffile": ("localfile_path.png", open("localfile_path.png", "rb"), "application/octet-stream"),
}
try:
    response = requests.post(url, data=payload, files=files)
    print(response.text)
finally:
    for _, file_handle, _ in files.values():
        file_handle.close()

require "uri"
require "net/http"

url = URI("https://api.gugudata.com/imagerecognition/pdf2text?appkey={{appkey}}")
https = Net::HTTP.new(url.host, url.port)
https.use_ssl = true
request = Net::HTTP::Post.new(url)
files = [
  File.open("localfile_path.png"),
]
begin
  form_data = [
    ["pdffile", files[0], { filename: "localfile_path.png" }],
  ]
  request.set_form form_data, "multipart/form-data"
  response = https.request(request)
  puts response.read_body
ensure
  files.each(&:close)
end

import Foundation

let semaphore = DispatchSemaphore(value: 0)
var request = URLRequest(url: URL(string: "https://api.gugudata.com/imagerecognition/pdf2text?appkey={{appkey}}")!, timeoutInterval: .infinity)
request.httpMethod = "POST"
let boundary = "Boundary-\(UUID().uuidString)"
var body = Data()
func appendString(_ value: String) { body.append(value.data(using: .utf8)!) }
let pdffileData = try! Data(contentsOf: URL(fileURLWithPath: "localfile_path.png"))
appendString("--\(boundary)\r\n")
appendString("Content-Disposition: form-data; name=\"pdffile\"; filename=\"localfile_path.png\"\r\n")
appendString("Content-Type: application/octet-stream\r\n\r\n")
body.append(pdffileData)
appendString("\r\n")
appendString("--\(boundary)--\r\n")
request.addValue("multipart/form-data; boundary=\(boundary)", forHTTPHeaderField: "Content-Type")
request.httpBody = body
let task = URLSession.shared.dataTask(with: request) { data, response, error in
  defer { semaphore.signal() }
  guard let data = data else {
    print(String(describing: error))
    return
  }
  print(String(data: data, encoding: .utf8)!)
}
task.resume()
semaphore.wait()