Parse any document into structured blocks, and generate documents in 9 formats, with AILANG Parse — from Claude Code, Codex, ChatGPT, or the command line.
Claude Code — add the marketplace and install the plugin:
/plugin marketplace add sunholo-data/docparse-skill
/plugin install ailang-parse@ailang-parse-marketplace
Codex (CLI, IDE, app) — the same repo is a plugin marketplace; installing it adds the skill and the hosted MCP server:
codex plugin marketplace add sunholo-data/docparse-skill
# then inside codex: /plugins → AILANG Parse → InstallFirst use. The plugin connects to the hosted MCP server at
https://docparse.ailang.sunholo.com/mcp/connect/, which signs in with OAuth.
The first time a tool needs your account, the client opens a sign-in page —
sign in with Google or GitHub and click Allow. In Claude Code you can also
start it with /mcp → Authenticate; in Codex, codex mcp login ailang-parse.
The client keeps the token: you never copy or paste an API key. The access key
the app receives is listed on your
dashboard as oauth: …, and
you can revoke it there.
Then just ask:
"Parse this DOCX file and show me the headings"
"Extract the tables from report.xlsx"
"Turn these notes into a PowerPoint"
"Write this up as a Word document using letterhead.docx"
"How much would it cost to parse this PDF?"
To generate a document, the agent writes Markdown and converts it — front matter, tables, inline formatting, links and embedded images all carry through. Headers, footers, comments and tracked changes have no Markdown syntax, so they survive only when converting from a document that already has them.
The MCP tools use the hosted service, so documents parsed through them are uploaded. That is the right default for general use and needs no setup.
For material that must not leave the machine — confidential, client-privileged,
under NDA — use the local docparse CLI. It runs the same parsers and
generators from the public
ailang-parse repo on your own
hardware:
curl -fsSL https://www.sunholo.com/ailang-parse/install.sh | sh
docparse report.docx --output-dir ./parsed
docparse notes.md --convert slides.pptxOne command, no clone (ailang_parse 0.40.0+): it installs the AILANG runtime
if needed, fetches the published package (~400 KB), and puts docparse on your
PATH. --version, --prefix, --bindir and --uninstall are supported;
re-running is a no-op. PDFs need two more steps that are easy to miss:
brew install poppler # pdftotext, the default backend
# (apt install poppler-utils on Debian/Ubuntu)
docparse --install-backends # docling + liteparse, for scans and layoutWithout docling, a scanned PDF fails even on the default backend —
pdftotext escalates to it automatically when it finds no text layer.
If ailang is already installed, ailang install sunholo/ailang_parse
(0.42.0+) is a shorter route to a thin docparse: one file in, output beside
it — no --output-dir, batch, --describe or PDF backends.
The local CLI also does what the hosted API cannot: files over the hosted size
limit, audio and video, the slow local PDF backends (docling, liteparse —
hosted requests are capped at 30s), and AI generation from a prompt
(--generate). Full reference:
resources/local-cli.md.
Caveat: "local" is a property of the backend, not the CLI. Office, ODF,
text, HTML, EPUB, email and pdftotext/docling/liteparse PDFs never touch
the network — but --pdf-backend ai, --describe, --summarize, images and
audio/video send content to an AI provider.
The skill carries this decision rule, so the agent says which path a given parse uses and does not upload a document by accident.
| Tool | Purpose |
|---|---|
mcpParse |
Parse any document into blocks, Markdown, HTML, A2UI, or a short summary; long results come in parts (page.nextCursor) |
mcpConvert |
Generate a document — docx, pptx, xlsx, odt, odp, ods, html, md, qmd — with a one-hour download link |
editDocument |
Parse a document, apply JSON edit deltas, return modified blocks (Office formats only) |
createUpload |
One-time upload links with a curl line, for files in a sandbox or workspace (Claude Code, Codex) |
uploadDocument |
An upload card in the chat (claude.ai and other MCP Apps hosts): the user picks the file |
mcpFormats |
Discover formats, samples and how to send a document (no sign-in) |
mcpEstimate |
Predict cost/latency before parsing (no sign-in) |
mcpAccount |
Plan, usage, keys and the request-history setting |
submit_feedback |
Report a bug / feature / docs gap to the maintainers |
Uploaded files come back as a fileRef that the same user can reuse for 30
minutes after its first use; in ChatGPT the attached file is passed directly
(file, via openai/fileParams). Parse acts only on the files you or the
assistant explicitly pass to a tool.
Plus the skill: when to use the local CLI vs the hosted API, how to author documents (writing quality, templates, verification), and wrapper scripts.
Parsing (17):
| Category | Formats | Speed |
|---|---|---|
| Office | DOCX, PPTX, XLSX, ODT, ODP, ODS | 5-50ms deterministic |
| Text | CSV, Markdown, HTML, EPUB, EML, MBOX, TEX, RTF | 5-15ms deterministic |
| PDF / image | PDF, PNG, JPG | PDF: pdftotext, no AI (pdfBackend="ai" for scans); images: AI |
| Audio / video | WAV, MP3, MP4, and other media | local CLI only — the hosted API rejects these |
Generation (9): DOCX, PPTX, XLSX, ODT, ODP, ODS, HTML, Markdown, QMD (Quarto)
Ask mcpFormats for the live list — it is the service's own answer and never
goes stale.
Per document, not per page: each parse or conversion is one request, whatever its length.
| Tier | Monthly | Requests | AI requests (images; PDFs only with pdfBackend="ai") |
Max file |
|---|---|---|---|---|
| Free | EUR 0 | 1,000 | 50 | 10 MB |
| Pro | EUR 29 | 100,000 | 500 | 25 MB |
| Business | EUR 99 | 500,000 | 2,000 | 50 MB |
The skill's shell scripts and the REST API take a dp_ API key instead of
OAuth:
export DOCPARSE_API_KEY="dp_your_key_here" # from the dashboard, or:
bash plugins/ailang-parse/skills/ailang-parse/scripts/device-auth.shLocal files are uploaded (the API never reads a path on your disk), and the
scripts send the key as a header. Headless MCP clients without a browser can
use the agent surface https://docparse.ailang.sunholo.com/mcp/, which adds the
device-auth tools (mcpAuth, mcpAuthPoll) and takes the key as an
Authorization: Bearer or X-API-Key header. Endpoint reference:
resources/api-reference.md.
The OpenAI portal reads authentication from the package's mcp.json, under
extensions["com.openai"].auth. That block lives in
openai-submission/mcp.json and declares OAuth with
CIMD client registration ("type": "mixed", because mcpFormats, mcpEstimate
and submit_feedback need no sign-in; "client": {"mode": "cimd"}; no client ID,
no secret, no headers). It is not in plugins/ailang-parse/mcp.json because the
Codex CLI drops an MCP server whose entry carries extensions. Build the ZIP to
upload with:
bash scripts/build-openai-submission.sh # -> dist/ailang-parse-<version>-openai.zipCodex discovers user-wide skills in ~/.agents/skills and follows symlinked
skill folders, so a clone of this repo can be the single source of truth:
git clone https://github.com/sunholo-data/docparse-skill && cd docparse-skill
DOCPARSE_SKILL_REPO="$(pwd -P)"
mkdir -p ~/.agents/skills
ln -s "$DOCPARSE_SKILL_REPO/plugins/ailang-parse/skills/ailang-parse" ~/.agents/skills/ailang-parse
# Claude, instead of (not as well as) the marketplace plugin:
mkdir -p ~/.claude/skills
ln -s "$DOCPARSE_SKILL_REPO/plugins/ailang-parse/skills/ailang-parse" ~/.claude/skills/ailang-parseInspect any existing skill directory or symlink before replacing it, and avoid
installing both the standalone skill and the plugin in Claude (duplicate skill
entries). git pull --ff-only updates linked installs; a cached marketplace
plugin needs its own update. In Codex, invoke $ailang-parse or just ask; if
the skill is missing from the selector, restart Codex.
A skill symlink does not register the MCP server. The local CLI works without it; for hosted access add it separately:
codex mcp add ailang-parse --url https://docparse.ailang.sunholo.com/mcp/connect/Codex starts the OAuth sign-in when it adds the server (or later with
codex mcp login ailang-parse). See
Codex skills and
MCP configuration.
pi does not load MCP servers, so pi users install the sibling extension:
pi-extension/ registers native pi tools (docparse_parse,
docparse_convert, docparse_generate, docparse_status) plus a
/docparse-login device-flow command, calling the local CLI and the hosted
REST API:
ln -s "$DOCPARSE_SKILL_REPO/pi-extension" ~/.pi/agent/extensions/docparseThe skill's scripts/audit.sh and scripts/render.sh wrap the AILANG Parse
companions docparse-audit and docparse-render, which the curl | sh
installer puts on PATH (ailang_parse 0.41.0+; the thin ailang install shim
does not include them). Set DOCPARSE_AUDIT_BIN / DOCPARSE_RENDER_BIN to
override. Office rendering additionally needs LibreOffice and Poppler.
One plugin directory serves both ecosystems; the skill and the MCP URL exist once.
| File | Read by |
|---|---|
.claude-plugin/marketplace.json |
Claude Code |
.agents/plugins/marketplace.json |
Codex / ChatGPT |
plugins/ailang-parse/.claude-plugin/plugin.json + .mcp.json |
Claude Code |
plugins/ailang-parse/plugin.json + mcp.json |
Agent Plugins — Codex, ChatGPT, OpenAI Plugin Directory |
plugins/ailang-parse/skills/ailang-parse/ |
both (Agent Skills standard; agents/openai.yaml is Codex UI metadata) |
CI (validate.yml) runs claude plugin validate --strict, an install smoke
test in Codex, and scripts/validate-agent-plugins.mjs (Agent Plugins JSON
Schemas + same-version / same-MCP-URL / OpenAI listing-limit checks). Keep the
two plugin.json versions and the two MCP URLs in step.