Conversão de documentos para Markdown com Node.js

Se você está criando uma aplicação Node.js que recebe documentos enviados por usuários, provavelmente já olhou para uma pasta cheia de PDFs, arquivos DOCX e apresentações PPTX e se perguntou: como normalizo tudo isso para algo que meu pipeline de LLM realmente consiga usar?

Este artigo mostra como usar a API REST da AnyMD a partir de Node.js — com fetch, axios, tipos TypeScript, streaming e padrões de middleware Express para conversão de documentos em Markdown em escala de produção.

Por que gerar Markdown a partir de Node.js?

Aplicações Node.js lidam naturalmente com uploads de arquivos — Multer, Busboy, middleware Express. Mas converter esses uploads em texto limpo e estruturado para pipelines RAG ou dados de treinamento de IA geralmente exige bindings nativos pesados (PyMuPDF, LibreOffice, pandoc) que não combinam com um runtime JS.

A AnyMD oferece uma API HTTP stateless. Uma chamada, uma resposta, Markdown limpo. Sem dependências nativas, sem bibliotecas de formatos no servidor e sem subprocessos Python na sua aplicação Node.js.

Início rápido com fetch (sem dependências)

Node.js 18+ inclui fetch globalmente. A conversão única mais simples é:

const fs = require("fs");
const { readFile } = require("fs/promises");

async function convertToMarkdown(filePath, apiKey) {
  const form = new FormData();
  form.set("file", new Blob([await readFile(filePath)]), filePath);

  const resp = await fetch("https://anymd.net/api/convert", {
    method: "POST",
    headers: { Authorization: `Bearer ${apiKey}` },
    body: form,
  });

  if (!resp.ok) {
    throw new Error(`AnyMD error ${resp.status}: ${await resp.text()}`);
  }

  return await resp.text();
}

// Usage
const md = await convertToMarkdown("report.docx", "your-api-key");
console.log(md);

É só isso. A AnyMD detecta automaticamente o formato pela extensão do arquivo e retorna GitHub-Flavored Markdown.

TypeScript com respostas tipadas

Para projetos TypeScript, adicione tipos de retorno adequados e tratamento de erros:

interface ConversionResult {
  markdown: string;
  format: string;
  pages: number;
  duration: number;
}

interface ConversionError {
  status: number;
  message: string;
}

async function convertToMarkdownTyped(
  filePath: string,
  apiKey: string
): Promise<ConversionResult> {
  const form = new FormData();
  const buffer = await fs.promises.readFile(filePath);
  form.set("file", new Blob([buffer]), filePath);

  const start = performance.now();
  const resp = await fetch("https://anymd.net/api/convert", {
    method: "POST",
    headers: { Authorization: `Bearer ${apiKey}` },
    body: form,
  });
  const duration = performance.now() - start;

  if (!resp.ok) {
    const err: ConversionError = {
      status: resp.status,
      message: await resp.text(),
    };
    throw err;
  }

  return {
    markdown: await resp.text(),
    format: filePath.split(".").pop() || "unknown",
    pages: parseInt(resp.headers.get("X-Pages") || "0", 10),
    duration: Math.round(duration),
  };
}

Middleware Express para endpoints de upload

Veja como integrar a AnyMD a um servidor Express com Multer para uploads de arquivos:

import express from "express";
import multer from "multer";
import fs from "fs/promises";

const app = express();
const upload = multer({ dest: "/tmp/uploads/" });
const ANYMD_API = "https://anymd.net/api/convert";

app.post("/upload", upload.single("file"), async (req, res) => {
  try {
    const apiKey = req.headers["authorization"]?.replace("Bearer ", "");
    if (!apiKey) return res.status(401).json({ error: "Missing API key" });

    const form = new FormData();
    const buffer = await fs.readFile(req.file.path);
    form.set("file", new Blob([buffer]), req.file.originalname);

    const anymdResp = await fetch(ANYMD_API, {
      method: "POST",
      headers: { Authorization: `Bearer ${apiKey}` },
      body: form,
    });

    if (!anymdResp.ok) {
      return res.status(anymdResp.status).json({
        error: await anymdResp.text(),
      });
    }

    const markdown = await anymdResp.text();
    res.json({ markdown, pages: anymdResp.headers.get("X-Pages") });
  } catch (err) {
    res.status(500).json({ error: err.message });
  } finally {
    if (req.file) fs.unlink(req.file.path).catch(() => {});
  }
});

app.listen(3000);

Processamento em lote com axios e novas tentativas

Quando você tem centenas de documentos para processar, chamadas sequenciais são lentas demais. Veja um processador em lote concorrente usando axios:

import axios from "axios";
import FormData from "form-data";
import fs from "fs";
import path from "path";
import pLimit from "p-limit";

const API = "https://anymd.net/api/convert";

async function convertOne(filePath, apiKey) {
  const form = new FormData();
  form.append("file", fs.createReadStream(filePath), path.basename(filePath));

  for (let attempt = 0; attempt < 3; attempt++) {
    try {
      const resp = await axios.post(API, form, {
        headers: {
          ...form.getHeaders(),
          Authorization: `Bearer ${apiKey}`,
        },
        maxContentLength: 50 * 1024 * 1024,
        timeout: 30_000,
      });

      const outPath = filePath.replace(path.extname(filePath), ".md");
      fs.writeFileSync(outPath, resp.data);
      return { file: path.basename(filePath), ok: true };
    } catch (err) {
      if (attempt === 2) return { file: path.basename(filePath), ok: false, error: err.message };
      const delay = Math.pow(1.5, attempt) * 1000;
      await new Promise(r => setTimeout(r, delay));
    }
  }
}

async function batchConvert(dir, apiKey, concurrency = 10) {
  const files = fs.readdirSync(dir).filter(f =>
    /\.(docx|pdf|pptx|xlsx|epub|odt|rtf)$/i.test(f)
  );
  const limit = pLimit(concurrency);
  const results = await Promise.all(
    files.map(f => limit(() => convertOne(path.join(dir, f), apiKey)))
  );

  const ok = results.filter(r => r.ok).length;
  console.log(`${ok}/${results.length} converted`);
  return results;
}

await batchConvert("./documents", "your-api-key", 10);

Streaming de documentos grandes

Para documentos com mais de 10 MB, use o endpoint de streaming para evitar armazenar toda a saída Markdown em memória.

Comparação com bibliotecas locais de Node.js

Formato	Biblioteca Node.js	AnyMD
DOCX	mammoth — sem suporte a PPTX/PDF/XLSX	Uma API, mais de 15 formatos
PDF	pdf-parse — perde tabelas e títulos	GFM, preserva a estrutura
PPTX	pptx2md — somente CLI, sem API	API REST, pipeline assíncrono
XLSX	xlsx — exportação CSV, sem Markdown	Tabelas → tabelas GFM
EPUB	epub2md — sem manutenção desde 2022	API ativa e versionada

Desempenho: Node.js falando com Rust

A AnyMD roda em um backend Rust/Axum.

Formato	Tamanho do documento	AnyMD (ms)	Biblioteca local (ms)
DOCX	50 KB (10 páginas)	280	620 (mammoth)
PDF	120 KB (15 páginas)	410	2,100 (pdf-parse)
PPTX	200 KB (20 slides)	520	1,800 (pptx2md)
XLSX	80 KB (5 planilhas)	340	950 (xlsx + formatação manual)

De Markdown para um pipeline RAG

Quando sua aplicação Node.js já tem Markdown limpo, o próximo passo é fazer chunking e embeddings para busca vetorial. A saída da AnyMD é a entrada ideal para chunking semântico — limites de títulos, estrutura de listas e cabeçalhos de tabelas são preservados.

Preços

Plano	Páginas/mês	Tamanho máximo do arquivo	Preço
Grátis	100	10 MB	$0
Starter	500	25 MB	$19
Pro	5,000	50 MB	$99
Empresarial	Personalizado	Personalizado	Personalizado

Um documento típico é convertido em menos de 0,5 segundo. 100 páginas grátis por mês — sem cartão de crédito.

Obtenha sua chave de API gratuita e comece hoje mesmo a converter documentos em Markdown a partir de Node.js.