Referencia

#include <markpdf/client.hpp>

markpdf::ClientOptions opts;
opts.apiKey = "YOUR_API_KEY";                  // or MARKPDF_API_KEY environment variable if omitted
opts.baseUrl = "https://api.markpdf.tech";  // optional, production default
opts.timeoutMs = 300000;                     // default 300000 (5 min)
opts.maxRetries = 2;                         // reintentos en 429/5xx

markpdf::Client client(opts);
// or, for the simple case:
markpdf::Client client2("YOUR_API_KEY");

struct ConvertOptions {
    std::string filename;
    InputFormat inputFormat = InputFormat::Auto;
    Mode mode = Mode::Fast;
    Engine engine = Engine::Auto;
    bool clean = true;
    bool imageOcr = false;
    bool hybridOcr = false;
    ResponseFormat responseFormat = ResponseFormat::Markdown;
    std::optional<std::string> pages;
    std::optional<std::string> outputUrl;
    OutputEncoding outputEncoding = OutputEncoding::Identity;
    std::optional<std::string> outputHeadUrl;
    bool autoPoll = true;
};

Result<ConversionResult, MarkpdfError>
Client::convertFile(const std::string& path, const ConvertOptions& opts = {});

Result<ConversionResult, MarkpdfError>
Client::convertFromUrl(const std::string& url, const ConvertOptions& opts = {});

void Client::convertStream(
    const std::string& pathOrUrl,
    StreamSource source,                     // StreamSource::File o StreamSource::Url
    const std::function<void(std::string_view chunk)>& onChunk,
    const StreamOptions& opts = {}
);

struct StreamOptions {
    std::string filename;
    InputFormat inputFormat = InputFormat::Auto;
    bool clean = true;
    bool slim = true;
    StreamSlimStrategy strategy = StreamSlimStrategy::Sampled;
};

Result<PdfSpine, MarkpdfError>
Client::pdfIndex(const std::string& url, const std::string& filename = "");

Result<JobStatus, MarkpdfError>
Client::getJob(const std::string& jobId);

struct Timings {
    int convertMs, cleanMs, totalWorkerMs, uploadMs, totalRequestMs;
};

struct ConversionResult {
    std::string markdown;
    std::string filename;
    std::string inputFormat;
    std::string engine;
    long sizeBytes;
    long markdownBytes;
    long tokenSavedEstimate;
    Timings timings;
};

struct Section { int page; int level; std::string text; };
struct PageInfo { int page; int chars; std::string firstLine; };

struct PdfSpine {
    int pageCount;
    long inputBytes;
    std::vector<Section> sections;
    std::vector<std::string> repeatedHeadersFooters;
    std::vector<PageInfo> pages;
    bool pagesTruncated;
    long estimatedTokensFull;
    long estimatedTokensSpineOnly;
};

enum class JobState { Queued, Processing, Completed, Failed };

struct JobStatus {
    std::string jobId;
    JobState status;
    std::optional<std::string> body;   // presente si status == Completed
    std::optional<std::string> error;  // presente si status == Failed
};

auto result = client.convertFile("report.pdf");
if (result) {
    use(result.value());   // o *result
} else {
    handle(result.error()); // MarkpdfError
}