LlmFiles API

At a glance

• Endpoint: POST /api/convert, multipart/form-data, a single field: file.
• Response: JSON with a markdown field and four more (below).
• Batch: POST /api/convert/batch takes up to 20 files in one request and answers with a result for each of them.
• Archive: POST /api/convert/zip takes the same request and returns a .zip with a separate .md for every file inside.
• Key is optional: without one the free quota applies. A license key lifts the limit.
• Base URL: https://llmfiles.com.

First request in 10 seconds

curl -F "[email protected]" \
  https://llmfiles.com/api/convert

The response is a single JSON object. The Markdown sits in the markdown field as one string with real newlines, so jq -r .markdown gives you a finished file:

curl -s -F "[email protected]" \
  https://llmfiles.com/api/convert \
  | jq -r .markdown > report.md

The file extension is not decoration: it selects the converter. report.pdf is parsed as PDF, report.docx as Word, and a file with no extension goes to plain-text extraction or to the fallback path.

What the response contains

Response headers let the client track what is left without a second call:

Limits

The day is the server calendar date (UTC+4) and the counter is keyed to the IP: cf-connecting-ip behind Cloudflare, otherwise the first address in X-Forwarded-For. Cookies play no part in quota counting: otherwise clearing cookies would buy a fresh limit on every request. You can read your own IP from the used field of the /api/license response.

Hit the limit and the server returns 402 with a message about 5 files per day. That is not a client error: retrying is pointless until the next day, so the plan is what has to change.

ZIP archives: a batch of files in one request

Available since version 1.4.0. Inside the archive every file is parsed by its own converter: DOCX stays a document with headings, CSV becomes a table, HTML becomes text, and the output holds a separate .md per file. The folder structure is preserved and extensions are replaced with .md.

curl -F "[email protected]" \
  https://llmfiles.com/api/convert/zip \
  -o docs-markdown.zip

unzip -o docs-markdown.zip -d out

Alongside the .md files the output archive contains _manifest.md: a table of archive file → .md file → size, plus the list of skipped entries with reasons. That way you can process a batch without checking anything by hand.

Batch: many files in one request

Available since version 1.7.0. One request carries up to 20 files under the same field name files. Each file gets its own converter and its own result, so one bad file does not sink the whole batch, and the caller can retry exactly the entries that failed.

curl -F "[email protected]" -F "[email protected]" -F "[email protected]" \
  https://llmfiles.com/api/convert/batch \
  | jq '{converted, failed, skipped, files: [.files[] | {filename, ok}]}'

The response holds counters, a per-file array in the same order as the request, and the quota state after the batch:

{
  "count": 3,
  "converted": 2,
  "failed": 1,
  "skipped": 0,
  "files": [
    {"filename": "report.pdf", "ok": true, "title": "report", "markdown": "# …", "fallback": false, "size": 812345},
    {"filename": "notes.docx", "ok": true, "title": "notes", "markdown": "## …", "fallback": false, "size": 12034},
    {"filename": "data.csv", "ok": false, "error": "Empty file", "size": 0}
  ],
  "quota": {"plan": "free", "limit": 5, "used": 2, "remaining": 3}
}

• Quota: one conversion per converted file. That differs from an archive, where the whole .zip counts as one.
• Running out of quota mid-batch: the files that fit are converted and the rest come back with a skipped reason instead of failing the request. If the limit left no room for a single file, the response is 402, exactly like a single conversion.
• Files per request: 20. Beyond that the answer is 413: split the batch or send a .zip to /api/convert/zip.
• Archives inside a batch: not unpacked. Send the .zip on its own to /api/convert/zip; the entry comes back with an error saying so.
• Headers: X-Batch-Total, X-Batch-Converted, X-Batch-Failed, X-Batch-Skipped, plus the usual X-Quota-*.
• Size limits: the same per-file limit as your plan, and 4x that per request (at most 300 MB).

Python

import requests

API = "https://llmfiles.com/api/convert"

def to_markdown(path: str, license_key: str | None = None) -> str:
    headers = {"X-License-Key": license_key} if license_key else {}
    with open(path, "rb") as fh:
        r = requests.post(API, files={"file": (path, fh)}, headers=headers, timeout=300)
    if r.status_code == 402:
        raise RuntimeError("daily limit reached: " + r.json()["detail"])
    r.raise_for_status()
    data = r.json()
    if data["fallback"]:
        print("unrecognized format:", data["filename"])
    return data["markdown"]

print(to_markdown("report.pdf")[:400])

When converting a batch, read X-Quota-Remaining after each file so the loop stops on its own instead of on a 402.

JavaScript

async function toMarkdown(file, licenseKey) {
  const body = new FormData();
  body.append('file', file);
  const res = await fetch('https://llmfiles.com/api/convert', {
    method: 'POST',
    body,
    headers: licenseKey ? { 'X-License-Key': licenseKey } : {},
  });
  if (!res.ok) throw new Error(`HTTP ${res.status}: ${(await res.json()).detail}`);
  return (await res.json()).markdown;
}

document.querySelector('input[type=file]').onchange = async (e) => {
  const md = await toMarkdown(e.target.files[0]);
  console.log(md.slice(0, 500));
};

CORS is open to all origins (Access-Control-Allow-Origin: *), so you can call the API straight from a browser on your own domain, without a proxy. Do not hardcode your license key in client-side code: it is visible in the page source.

License key

Two equivalent ways to pass a Pro key. The header is the better fit for scripts and bots:

curl -F "[email protected]" \
  -H "X-License-Key: MIW-PRO-XXXXXXXX-XXXXXXXX" \
  https://llmfiles.com/api/convert

The cookie is for the browser: POST /api/license/activate with a body of {"key": "MIW-PRO-…"} sets it for a year. A revoked key fails activation (404), and from then on requests fall back to the free quota.

One request confirms that the key took effect: the response reports plan: pro and remaining: null:

curl -s -H "X-License-Key: MIW-PRO-XXXXXXXX-XXXXXXXX" \
  https://llmfiles.com/api/license | jq '{plan, remaining}'

Other endpoints

There is no conversion-ready webhook: requests are synchronous and the response arrives on the same connection. For batches, send up to 20 files to POST /api/convert/batch in one request and read the per-file results; for anything larger, loop over your files and pause when X-Quota-Remaining reaches zero.

Error codes

Privacy and data

• The file is read into process memory and never written out: nothing on disk, nothing in the database, nothing sent to third-party APIs.
• The log records only that an event happened: type, path, hashed IP and size. File name and contents are not logged.
• The quota counter stores a hash of the IP and the date, with no cookies and no history of pages.
• If policy forbids sending documents outside at all, you need the on-prem edition: it runs inside your own network.

More on why this matters and how to verify it yourself is in the guide PDF to Markdown without the cloud.