Rust (with Active-Web)

PDF URL

use actix_web::{client::Client, post, web, App, HttpServer, Responder};
use serde::Deserialize;

#[derive(Deserialize)]
struct ExtractTextResponse {
    text: String,
}

#[post("/extract_text")]
async fn extract_text() -> impl Responder {
    let client = Client::default();
    let res = client
        .post("https://v1.mlapi.co/pdf/pdf-to-text")
        .send_form(&[("pdf_url", "https://example.com/your-pdf.pdf"), ("api_key", "your_api_key")])
        .await;

    match res {
        Ok(mut response) => {
            if response.status().is_success() {
                let body = response.body().await.unwrap();
                let text_response: ExtractTextResponse = serde_json::from_slice(&body).unwrap();
                text_response.text
            } else {
                format!("Error: {}", response.status())
            }
        }
        Err(e) => format!("Error: {}", e),
    }
}

#[actix_web::main]
async fn main() -> std::io::Result<()> {
    HttpServer::new(|| App::new().service(extract_text))
        .bind("127.0.0.1:8080")?
        .run()
        .await
}

Upload PDF file

use actix_multipart::Multipart;
use actix_web::{post, web, App, HttpServer, Responder};
use futures_util::stream::StreamExt as _;

#[post("/extract_text")]
async fn extract_text(mut payload: Multipart) -> impl Responder {
    let mut form_data = Vec::new();

    while let Some(item) = payload.next().await {
        let mut field = item.unwrap();
        let mut bytes = web::BytesMut::new();

        while let Some(chunk) = field.next().await {
            bytes.extend_from_slice(&chunk.unwrap());
        }

        form_data.push((field.content_disposition().unwrap().get_name().unwrap().to_string(), bytes));
    }

    let client = Client::default();
    let res = client
        .post("https://v1.mlapi.co/pdf/pdf-to-text")
        .send_body(form_data)
        .await;

    match res {
        Ok(mut response) => {
            if response.status().is_success() {
                let body = response.body().await.unwrap();
                let text_response: ExtractTextResponse = serde_json::from_slice(&body).unwrap();
                text_response.text
            } else {
                format!("Error: {}", response.status())
            }
        }
        Err(e) => format!("Error: {}", e),
    }
}

#[actix_web::main]
async fn main() -> std::io::Result<()> {
    HttpServer::new(|| App::new().service(extract_text))
        .bind("127.0.0.1:8080")?
        .run()
        .await
}