> ## Documentation Index
> Fetch the complete documentation index at: https://docs.markpdf.tech/llms.txt
> Use this file to discover all available pages before exploring further.

# Ejemplos

> Casos de uso reales de markpdf-cpp: cargas, archivos PDF grandes, BYOS, RAG y ZIP.

# Ejemplos

## Convertir un archivo cargado a la memoria

```cpp theme={null}
#include <markpdf/client.hpp>

markpdf::Client client("YOUR_API_KEY");

// When you already have the bytes in memory (e.g. read from a socket or multipart)
std::vector<uint8_t> bytes = readUploadedBytes();

markpdf::ConvertOptions opts;
opts.filename = "report.pdf";
opts.mode = markpdf::Mode::Fast;

auto result = client.convertBytes(bytes, opts);
if (result) {
    send(result->markdown);
}
```

`convertBytes(data, opts)` es la variante de `convertFile` para cuando el contenido ya está en la memoria y no deseas tocar el sistema de archivos.

## PDF grande con rango de páginas

```cpp theme={null}
markdown::ConvertOptions opts;
opts.pages = "120-145";
opts.mode = markpdf::Mode::Fast;

auto result = client.convertFromUrl(
    "https://bucket.example.com/manual-800-papages.pdf?sig=...", opts);
```

Combínelo con [`pdfIndex`](/docs/public/es/sdks/cpp/reference#pdfindex) para saber qué rango ordenar sin descargar todo el PDF del lado del cliente.

## BYOS: sube el resultado directamente a tu almacenamiento

```cpp theme={null}
markpdf::ConvertOptions opts;
opts.responseFormat = markpdf::ResponseFormat::Json;
opts.outputUrl = presignedPutUrl;      // pre-signed PUT to your bucket
opts.outputHeadUrl = presignedHeadUrl; // optional: detect cache hits

auto result = client.convertFromUrl(pdfUrl, opts);
if (result) {
    std::cout << result->outputUrl.value() << "\n";
}
```

Con `outputUrl`, API carga el Markdown directamente a su almacenamiento y devuelve un JSON liviano en lugar del cuerpo completo. Consulte [Compresión](/docs/public/es/concepts/compression) para `outputEncoding`.

## Canalización RAG con `pdfIndex`

```cpp theme={null}
markpdf::Client client("YOUR_API_KEY");
std::string pdf = "https://bucket.example.com/informe-anual.pdf?sig=...";

// 1. Index without converting the entire document
auto spineResult = client.pdfIndex(pdf);
if (!spineResult) return;
auto& spine = *spineResult;

// 2. Choose the section of interest
auto it = std::find_if(spine.sections.begin(), spine.sections.end(),
    [](const markpdf::Section& s) { return s.text.find("Resultados") != std::string::npos; });
int startPage = it->page;
auto next = std::find_if(it + 1, spine.sections.end(),
    [&](const markpdf::Section& s) { return s.page > startPage; });
int endPage = (next != spine.sections.end()) ? next->page - 1 : spine.pageCount;

// 3. Bring Markdown only from that section
markdown::ConvertOptions opts;
opts.pages = std::to_string(startPage) + "-" + std::to_string(endPage);
auto result = client.convertFromUrl(pdf, opts);
```

Consulte el [PDF Índice de agentes de IA](/docs/public/es/concepts/pdf-index-for-ai-agents).

## Procesar un ZIP

```cpp theme={null}
markpdf::ConvertOptions opts;
opts.inputFormat = markpdf::InputFormat::Zip;
opts.responseFormat = markpdf::ResponseFormat::Json;

auto result = client.convertFile("documents.zip", opts);
if (result) {
    std::cout << result->markdown; // Markdown concatenated from the documents inside the ZIP
}
```

<Warning>
  Los límites de tamaño y cantidad de archivos dentro de ZIP están en [Límites](/docs/public/es/concepts/limits). Un ZIP fuera de rango devuelve `413`, asignado a `ErrorKind::PayloadTooLarge`.
</Warning>

## Convertir varios archivos en paralelo con `std::async`

```cpp theme={null}
#include <future>
#include <vector>

std::vector<std::string> paths = {"a.pdf", "b.pdf", "c.pdf"};
std::vector<std::future<markpdf::Result<markpdf::ConversionResult, markpdf::MarkpdfError>>> futures;

for (const auto& p : paths) {
    futures.push_back(std::async(std::launch::async, [&client, p]() {
        markpdf::ConvertOptions opts;
        opts.mode = markpdf::Mode::Fast;
        return client.convertFile(p, opts);
    }));
}

for (auto& f : futures) {
    auto result = f.get();
    if (result) {
        std::cout << result->filename << ": " << result->markdown.size() << " bytes\n";
    }
}
```

<Tip>
  `markpdf::Client` mantiene un grupo interno de `curl easy handle` para admitir llamadas simultáneas desde múltiples subprocesos sin que cada uno tenga que crear su propio cliente.
</Tip>