Best Docling Alternative for RAG Pipeline Ingestion

EnConvert is a Docling alternative for RAG pipeline ingestion that parses PDFs and DOCX into heading-aware chunks through one API, with nothing to install

Get API key

A developer building a RAG pipeline needs document parsing that returns clean, structured output without installing dependencies, managing compute, or maintaining a local library. Docling is an open-source document parsing library that originated at IBM Research and converts PDFs, DOCX, and other formats into structured Markdown or JSON. It produces high-quality output and runs locally, which suits sensitive data, but it requires installation, Python environment management, and compute that you provision and maintain. For a team that wants document ingestion as a managed API step rather than a hosted process of its own, that infrastructure sits between the document and the vector store. EnConvert is a REST API and MCP server that accepts document uploads and returns heading-aware JSONL chunks with no installation, no dependency management, and no compute to provision, so you get structured RAG-ready output from any document in one API call.

Example

python
import os
import json
import time

import requests
from docling.chunking import HybridChunker
from docling.document_converter import DocumentConverter

FILE_PATH = "/path/to/your/report.pdf"  # a local PDF, DOCX, PPTX, XLSX, CSV, HTML, or Markdown file
HEADERS = {"X-API-Key": os.environ["ENCONVERT_API_KEY"]}

# Docling: convert and chunk locally
# (pip install docling; needs Python 3.10+ and compute you provide)
converter = DocumentConverter()
result = converter.convert(FILE_PATH)

chunker = HybridChunker()
docling_chunks = [chunk.text for chunk in chunker.chunk(dl_doc=result.document)]

# EnConvert: upload the file, poll for completion, download JSONL chunks
# Step 1: Upload the file (the multipart field is named "files")
with open(FILE_PATH, "rb") as f:
    upload = requests.post(
        "https://api.enconvert.com/v2/ingest/files",
        headers=HEADERS,
        files={"files": (os.path.basename(FILE_PATH), f)},
        timeout=120,
    )
upload.raise_for_status()
job_id = upload.json()["job_id"]

# Step 2: Poll until the job completes (give up after 5 minutes)
deadline = time.monotonic() + 300
while True:
    poll = requests.get(
        f"https://api.enconvert.com/v2/ingest/{job_id}",
        headers=HEADERS,
        timeout=30,
    )
    poll.raise_for_status()
    job = poll.json()
    if job["status"] == "completed":
        break
    if job["status"] in ("failed", "canceled"):
        raise RuntimeError(f"Ingest {job['status']}: {job.get('error_message')}")
    if time.monotonic() > deadline:
        raise TimeoutError(f"Ingest job {job_id} is still {job['status']} after 5 minutes")
    time.sleep(2)

# Step 3: Download the JSONL, one chunk per line. The output_url is a signed URL
# (valid 15 minutes): plain GET, no API key.
jsonl = requests.get(job["output_url"], timeout=60)
jsonl.raise_for_status()
chunks = [json.loads(line) for line in jsonl.iter_lines() if line]

print(f"Docling: {len(docling_chunks)} chunks, EnConvert: {len(chunks)} chunks")

# Each chunk has "content" (the text to embed) plus "metadata": source_url (the
# filename), title, headings_path (a list of headings), section, word_count, chunk_index
if chunks:
    first = chunks[0]
    print(first["metadata"]["headings_path"], first["content"][:200])

What you get back

Capability

EnConvert

Docling

Setup required

API key and one POST request

pip install docling, Python 3.10+, and dependency management

Hosting

Managed API

Self-hosted; runs as a local library or a docling-serve container

Supported input formats

Ingest: PDF, DOCX, XLSX, CSV, Markdown, and plain text; chunks split at H1 to H3 boundaries, 512 word soft cap, tables and code blocks kept whole; web pages and URL lists via Perceive or Ingest

PDF, DOCX, PPTX, XLSX, HTML, images, audio, and more; some formats require optional dependencies

Output format

One consistent schema across all endpoints: Markdown from Perceive and Distill, JSONL chunks from Ingest split at H1 to H3 boundaries with tables and code blocks kept whole

Markdown, HTML, DocTags, and lossless JSON

RAG-ready chunked output

Confirmed: chunks split at H1 to H3 heading boundaries, 512 word default soft cap, tables and code blocks kept whole even when they exceed the cap; each chunk carries headings_path, section, chunk_index, and word_count

Confirmed: HybridChunker and HierarchicalChunker, configured and run locally

Web page ingestion

Perceive: any URL to clean Markdown, including JavaScript-rendered pages; Ingest also accepts URL lists, sitemaps, and website crawls returning the same JSONL chunk schema as file ingestion

HTML and URL sources supported; JavaScript rendering not documented

MCP server

Native, exposes full ingestion toolkit as MCP tools

Confirmed: MCP server available

Free tier

500 ops per month, no card required

Open source and free to run; you pay for your own compute

WHY ENCONVERT FOR RAG PIPELINE INGESTION

Managed API ingestion means no local installation or compute to provision, and one set of endpoints handles files and web pages, so pipeline code does not branch by input type. Improvements to parsing reach you on the service side without a library upgrade on yours. When the pipeline grows, the same API covers web pages through Perceive and summarisation through Distill, so the integration does not change as the input surface expands.

Get free API key — 500 ops per month, no card required.