> ## 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.

# Referencia

> Clases, métodos y opciones de cliente de Node.js/TypeScript.

\#Referencia

## `MarkpdfClient`

```ts theme={null}
import { MarkpdfClient } from "@markpdf/sdk";

const client = new MarkpdfClient({
  apiKey: "YOUR_API_KEY",              // o process.env.MARKPDF_API_KEY
  baseUrl: "https://api.markpdf.tech", // optional, production default
  timeoutMs: 300_000,                 // default 300000 (5 min)
  maxRetries: 2,                      // reintentos en 429/5xx
});
```

<ParamField body="apiKey" type="string" required>
  Su clave API. Si no lo pasa, el cliente lee `process.env.MARKPDF_API_KEY` (Nodo) o `Deno.env` (Deno).
</ParamField>

<ParamField body="baseUrl" type="string" default="https://api.markpdf.tech">
  URL base de API.
</ParamField>

<ParamField body="timeoutMs" type="number" default="300000">
  Tiempo de espera por solicitud en milisegundos, implementado con `AbortController`.
</ParamField>

<ParamField body="maxRetries" type="number" default="2">
  Reintentos automáticos con retroceso exponencial en `429` y `5xx`.
</ParamField>

<ParamField body="fetch" type="typeof fetch">
  Implementación de `fetch` para usar. De forma predeterminada, utiliza el `fetch` global del tiempo de ejecución. Útil para inyectar un `fetch` con un proxy o para pruebas.
</ParamField>

## Métodos

Todos aceptan las mismas opciones que los [parámetros de consulta de API](/docs/public/es/api/parameters), en camelCase.

### `convertFile`

```ts theme={null}
client.convertFile(
  data: Buffer | Uint8Array | Blob | File,
  options?: {
    filename?: string;
    inputFormat?: InputFormat;   // default "auto"
    mode?: ConvertMode;          // default "fast"
    engine?: Engine;             // default "auto"
    clean?: boolean;             // default true
    imageOcr?: boolean;          // default false
    hybridOcr?: boolean;         // default false
    responseFormat?: "markdown" | "json"; // default "markdown"
    pages?: string;
    outputUrl?: string;
    outputEncoding?: "identity" | "gzip" | "zstd";
    outputHeadUrl?: string;
    autoPoll?: boolean;          // default true
  }
): Promise<string | ConversionResult>
```

Sube contenido a `POST /convert/raw`. Devuelve `Promise<string>` con Markdown, o `Promise<ConversionResult>` si `responseFormat: "json"`.

<ParamField body="autoPoll" type="boolean" default="true">
  Si el servidor responde `202` (backends saturados), SDK sondea automáticamente `GET /jobs/{id}`. Con `autoPoll: false`, el método arroja `MarkpdfJobQueuedError` con `jobId` para realizar una encuesta manual. Consulte [Transmisión y asíncrono](/docs/public/es/sdks/nodejs/streaming-and-async).
</ParamField>

### `convertFromUrl`

```ts theme={null}
client.convertFromUrl(
  url: string,
  options?: {
    filename?: string;
    inputFormat?: InputFormat;
    mode?: ConvertMode;
    engine?: Engine;
    clean?: boolean;
    imageOcr?: boolean;
    hybridOcr?: boolean;
    responseFormat?: "markdown" | "json";
    pages?: string;
    outputUrl?: string;
    outputEncoding?: "identity" | "gzip" | "zstd";
    outputHeadUrl?: string;
    autoPoll?: boolean;
  }
): Promise<string | ConversionResult>
```

Llama a `POST /convert/from-url`.

### `convertStream`

```ts theme={null}
client.convertStream(
  input: { data: Buffer | Blob | File } | { url: string },
  options?: {
    filename?: string;
    inputFormat?: InputFormat;
    clean?: boolean;
    slim?: boolean;                     // default true
    streamSlimStrategy?: "off" | "sampled" | "full"; // default "sampled"
  }
): AsyncIterable<string>
```

Devuelve un `AsyncIterable<string>` que emite fragmentos de Markdown a medida que llegan antes de `POST /convert/stream` o `/convert/stream-from-url`. Consulte [Transmisión y asíncrono](/docs/public/es/sdks/nodejs/streaming-and-async).

### `pdfIndex`

```ts theme={null}
client.pdfIndex(url: string, options?: { filename?: string }): Promise<PdfSpine>
```

Llame a `POST /pdf/index`. Devuelve el lomo escrito: los mismos campos que [`POST /pdf/index`](/docs/public/es/api/pdf-index).

```ts theme={null}
const spine = await client.pdfIndex("https://bucket.example.com/report.pdf?sig=...");
for (const section of spine.sections) {
  console.log(section.page, section.level, section.text);
}
```

### `getJob`

```ts theme={null}
client.getJob(jobId: string): Promise<JobStatus>
```

Consulta manualmente `GET /jobs/{id}`.

## Tipos

### `ConversionResult`

```ts theme={null}
interface ConversionResult {
  markdown: string;
  filename: string;
  inputFormat: string;
  engine: string;
  sizeBytes: number;
  markdownBytes: number;
  tokenSavedEstimate: number;
  timings: {
    convertMs: number;
    cleanMs: number;
    totalWorkerMs: number;
    uploadMs: number;
    totalRequestMs: number;
  };
}
```

### `PdfSpine`

```ts theme={null}
interface PdfSpine {
  pageCount: number;
  inputBytes: number;
  fontModel: { bodySize: number; headingSizes: number[] };
  sections: Array<{ page: number; level: number; text: string }>;
  repeatedHeadersFooters: string[];
  pages: Array<{ page: number; chars: number; firstLine: string; headings: unknown[] }>;
  pagesTruncated: boolean;
  estimatedTokensFull: number;
  estimatedTokensSpineOnly: number;
}
```

### `JobStatus`

```ts theme={null}
interface JobStatus {
  jobId: string;
  status: "queued" | "processing" | "completed" | "failed";
  body?: string | Record<string, unknown>;
  error?: string;
}
```

Todos los tipos se exportan desde `@markpdf/sdk` para que los utilices en tu propio código:

```ts theme={null}
import type { ConversionResult, PdfSpine, JobStatus, ConvertMode } from "@markpdf/sdk";
```