Model Download

When run for the first time, Marker will automatically download the required models from Hugging Face. These models include:

• Layout detection model
• OCR model (Surya)
• Table recognition model
• Mathematical formula conversion model

Total model size is approximately 2-3 GB. Ensure a stable internet connection during the first run.

Basic Usage

Single File Conversion via CLI

Marker provides an easy-to-use command-line interface:

Example Output

For instance, if you have a financial report PDF with tables, Marker will produce output like:

# Financial Report Q1 2026

Revenue Summary

| Category | Q1 2025 | Q1 2026 | Growth |
|----------|---------|---------|--------|
| Product A | $500K | $750K | 50% |
| Product B | $300K | $420K | 40% |
| Total | $800K | $1.17M | 46% |

Company revenue increased by 46% year-over-year...

Notice how the table is neatly converted to Markdown format with proper alignment.

Advanced Configuration

Setting Conversion Parameters

Marker provides various parameters to control the conversion process:

Advanced Usage

Integration with RAG Pipelines

One of Marker's primary use cases is preparing documents for RAG pipelines. Here's an example integration with LangChain:

import os
import json
import time
from marker.converters.pdf import PdfConverter
from marker.models import createmodeldict

from marker.output import textfromrendered


def batchconvertwithmonitoring(
    inputfolder: str,

    outputfolder: str,
    logfile: str = "conversionlog.json"
):
    """Batch convert with logging and error handling."""
    os.makedirs(outputfolder, existok=True)

    converter = PdfConverter(
        artifactdict=createmodeldict(),

    )

    pdffiles = [f for f in os.listdir(inputfolder) if f.endswith(".pdf")]

    total = len(pdffiles)
    results = []

    print(f"Processing {total} documents...")

    for i, filename in enumerate(pdffiles, 1):

        filepath = os.path.join(inputfolder, filename)
        starttime = time.time()


        try:
            rendered = converter(filepath)
            text, metadata, images = textfromrendered(rendered)


            # Save Markdown output
            outputname = filename.replace(".pdf", ".md")
            outputpath = os.path.join(outputfolder, outputname)


            with open(outputpath, "w", encoding="utf-8") as f:
                f.write(text)

            # Save images if any
            if images:
                imgfolder = os.path.join(

                    outputfolder,
                    filename.replace(".pdf", "images")

                )
                os.makedirs(imgfolder, existok=True)

                for imgname, imgdata in images.items():

                    imgpath = os.path.join(imgfolder, imgname)
                    with open(imgpath, "wb") as f:

                        f.write(imgdata)

            elapsed = time.time() - starttime

            result = {
                "file": filename,
                "status": "success",
                "output": outputpath,
                "pages": metadata.get("pages", 0),
                "timeseconds": round(elapsed, 2),

                "imagesextracted": len(images) if images else 0
            }

            print(f"[{i}/{total}] OK: {filename} ({elapsed:.1f}s)")

        except Exception as e:
            elapsed = time.time() - starttime

            result = {
                "file": filename,
                "status": "error",
                "error": str(e),
                "timeseconds": round(elapsed, 2)
            }
            print(f"[{i}/{total}] ERROR: {filename} - {e}")

        results.append(result)

    # Save log
    with open(logfile, "w") as f:

        json.dump(results, f, indent=2)

    success = sum(1 for r in results if r["status"] == "success")
    print(f"\nComplete: {success}/{total} successfully converted")
    print(f"Log saved to: {logfile}")

    return results

Run
results = batchconvertwithmonitoring(

    inputfolder="./pdfdocuments",

    outputfolder="./markdownoutput"

)

import os
import tempfile
from fastapi import FastAPI, UploadFile, File, HTTPException
from fastapi.responses import JSONResponse
from marker.converters.pdf import PdfConverter
from marker.models import createmodeldict

from marker.output import textfromrendered


app = FastAPI(title="Marker PDF Converter API")

converter = None

@app.onevent("startup")
async def loadmodels():

    global converter
    converter = PdfConverter(
        artifactdict=createmodeldict(),
    )

@app.post("/convert")
async def convertpdf(file: UploadFile = File(...)):

    """Convert PDF to Markdown."""
    if not file.filename.endswith((".pdf", ".epub", ".mobi")):
        raise HTTPException(
            statuscode=400,
            detail="Unsupported file format. Use PDF, EPUB, or MOBI."
        )

    with tempfile.NamedTemporaryFile(
        suffix=os.path.splitext(file.filename)[1],
        delete=False
    ) as tmp:
        content = await file.read()
        tmp.write(content)
        tmppath = tmp.name


    try:
        rendered = converter(tmppath)
        text, metadata, images = textfromrendered(rendered)

        return JSONResponse({
            "filename": file.filename,
            "markdown": text,
            "metadata": metadata,
            "imagescount": len(images) if images else 0

        })
    except Exception as e:
        raise HTTPException(statuscode=500, detail=str(e))
    finally:
        os.unlink(tmppath)


@app.get("/health")
async def health():
    return {"status": "ok", "modelloaded": converter is not None}

Run the server:

pip install fastapi uvicorn python-multipart
uvicorn markerapi:app --host 0.0.0.0 --port 8000

curl -X POST http://localhost:8000/convert \
  -F "file=@document.pdf" \
  | python -m json.tool

import time

def compareextraction(pdfpath: str):

    """Compare extraction results across different tools."""

    # Marker
    from marker.converters.pdf import PdfConverter
    from marker.models import createmodeldict

    from marker.output import textfromrendered


    start = time.time()
    converter = PdfConverter(artifactdict=createmodeldict())
    rendered = converter(pdfpath)

    markertext, ,  = textfromrendered(rendered)
    markertime = time.time() - start


    # PyPDF2
    from PyPDF2 import PdfReader

    start = time.time()
    reader = PdfReader(pdfpath)
    pypdftext = ""

    for page in reader.pages:
        pypdftext += page.extracttext() or ""

    pypdftime = time.time() - start

    # pdfminer
    from pdfminer.highlevel import extracttext

    start = time.time()
    pdfminertext = extracttext(pdfpath)

    pdfminertime = time.time() - start

    print("=== Comparison Results ===")
    print(f"Marker    : {len(markertext)} chars, {markertime:.2f}s")
    print(f"PyPDF2    : {len(pypdftext)} chars, {pypdftime:.2f}s")
    print(f"pdfminer  : {len(pdfminertext)} chars, {pdfminertime:.2f}s")
    print()
    print("--- Marker Output (first 500 chars) ---")
    print(markertext[:500])

    print()
    print("--- PyPDF2 Output (first 500 chars) ---")
    print(pypdftext[:500])

compareextraction("complexreport.pdf")

Best Practices

1. Memory Optimization for Large Documents

When processing large documents (hundreds of pages), pay attention to memory usage:

import gc
import torch

def processlargedocument(pdfpath: str, batchsize: int = 20):
    """Process large documents in page batches."""
    from marker.converters.pdf import PdfConverter
    from marker.models import createmodeldict
    from marker.output import textfromrendered
    import fitz  # PyMuPDF

    doc = fitz.open(pdfpath)

    totalpages = len(doc)
    doc.close()

    alltext = []

    converter = PdfConverter(artifactdict=createmodeldict())

    for start in range(0, totalpages, batchsize):
        end = min(start + batchsize, totalpages)
        rendered = converter(pdfpath, pagerange=[start, end])
        text, ,  = textfromrendered(rendered)
        alltext.append(text)


        gc.collect()
        if torch.cuda.isavailable():
            torch.cuda.emptycache()


    return "\n\n".join(alltext)

2. Caching Conversion Results

Avoid re-converting the same documents:

import hashlib
import json
import os

CACHEDIR = "./markercache"

def getfilehash(filepath: str) -> str:
    """Calculate SHA256 hash of a file."""
    sha256 = hashlib.sha256()
    with open(filepath, "rb") as f:
        for chunk in iter(lambda: f.read(8192), b""):
            sha256.update(chunk)
    return sha256.hexdigest()

def convertwithcache(pdfpath: str) -> str:

    """Convert with file-hash-based caching."""
    os.makedirs(CACHEDIR, existok=True)

    filehash = getfilehash(pdfpath)

    cachepath = os.path.join(CACHEDIR, f"{filehash}.json")

    if os.path.exists(cachepath):

        with open(cachepath, "r") as f:
            cached = json.load(f)
        print(f"Cache hit: {pdfpath}")

        return cached["text"]

    from marker.converters.pdf import PdfConverter
    from marker.models import createmodeldict

    from marker.output import textfromrendered


    converter = PdfConverter(artifactdict=createmodeldict())
    rendered = converter(pdfpath)

    text, metadata,  = textfromrendered(rendered)

    with open(cachepath, "w") as f:

        json.dump({"text": text, "metadata": metadata}, f)

    print(f"Converted and cached: {pdfpath}")
    return text

3. Output Validation

Always validate output quality before using it:

def validateconversion(text: str, minlength: int = 100) -> dict:
    """Validate conversion output quality."""
    issues = []

    if len(text) < minlength:

        issues.append(f"Text too short ({len(text)} chars)")

    lines = text.split("\n")
    emptyratio = sum(1 for l in lines if not l.strip()) / max(len(lines), 1)
    if emptyratio > 0.7:

        issues.append(f"Too many empty lines ({emptyratio:.0%})")

    garbled = sum(1 for c in text if ord(c) > 65535) / max(len(text), 1)
    if garbled > 0.05:
        issues.append(f"Possible garbled characters ({garbled:.1%})")

    tablecount = text.count("|---|")

    headingcount = text.count("\n#")

    return {
        "valid": len(issues) == 0,
        "issues": issues,
        "stats": {
            "length": len(text),
            "lines": len(lines),
            "tables": tablecount,

            "headings": headingcount,
            "emptylineratio": round(emptyratio, 2)

        }
    }