{"$schema":"https://static.modelcontextprotocol.io/schemas/v1/server-card.schema.json","name":"io.mdapi/mdapi","title":"mdapi.io MCP server","description":"Model Context Protocol server manifest for mdapi.io","version":"1.0.0","icons":[{"src":"https://mdapi.io/favicon.svg","mimeType":"image/svg+xml"}],"remotes":[{"type":"streamable-http","url":"https://mdapi.io/mcp","supportedProtocolVersions":["2026-07-28","2025-11-25","2025-06-18","2025-03-26","2024-11-05"]}],"protocolVersion":"2026-07-28","serverInfo":{"name":"mdapi","description":"Minimal Data API I/O: a content transformation layer primitive for AI systems. Transforms files and webpages into AI-ready Markdown and structured data, optimized for LLM efficiency and token usage.","version":"1.0.0"},"transport":{"type":"streamable-http","endpoint":"https://mdapi.io/mcp"},"capabilities":{"tools":{"listChanged":false},"resources":{"subscribe":false,"listChanged":false}},"tools":[{"name":"convert","title":"Convert to Markdown","description":"Converts files and webpages to Markdown. Supports: webpages, DOCX, DOC, DOT, WIZ, ODT, RTF, WPD, WP5, WP6, WP, DJVU, DJV, HC, STK, HWP, HWPX, UOF, UOT, SXW, IDML, ODM, DOCM, DOTX, DOTM, FODT, FOTT, OTT, ABW, ZABW, WPS, WPT, PAGES, JATS, TEI, DOCBOOK, DBK, DITA, DITAMAP, FB2, FB3, DAISY, DTBOOK, PDF, AI, XPS, OXPS, VSDX, PS, EPS, DVI, ENEX, FDX, MUSICXML, MXL, SKETCH, DRAWIO, XMIND, MMAP, ODG, EMF, WMF, ONE, ONETOC2, IPYNB, NB, XLSX, XLS, XLC, XLM, XLT, XLSM, XLSB, XLA, XLTX, XLTM, XLAM, ODS, FODS, OTS, ET, ETT, PMD, GNUMERIC, Numbers, DTA, RDS, RDA, RData, NPY, NPZ, HYPER, SLK, SYLK, DIF, PRN, FWF, WK1, WK2, WK3, WK4, SXC, UOS, PPTX, PPT, PPA, POT, PPS, PWZ, POTX, POTM, PPSX, PPSM, PPTM, DPS, DPT, ODP, FODP, OTP, KEY, SXI, UOP, DBF, FPT, DBT, ODB, MSI, BSON, BED, BEDGRAPH, BB, NARROWPEAK, BROADPEAK, GTF, GFF, GFF2, GFF3, FASTA, FA, FFN, FAA, FNA, FASTQ, FQ, GB, GBK, GBFF, EMBL, SAM, VCF, NEWICK, NEXUS, CIF, MMCIF, PDB, ENT, XYZ, NII, FITS, MRC, MRCS, EDF, BDF, NRRD, TIFF, TIF, GeoTIFF, DCM, JCAMP-DX, JDX, DX, JCAMP, NetCDF, NC, CDF, MZML, MZXML, CBF, MAP, MTZ, SAV, ZSAV, XPT, MAT, DM3, DM4, PARQUET, PQ, AVRO, ORC, ARROW, FTR, FEATHER, ARROWS, LANCE, SQLITE, DB, SQLITE3, MDB, ACCDB, DUCKDB, SAS7BDAT, TWB, TWBX, PBIX, HDF5, H5, HE5, HDF, MNC, NXS, SHP, GPX, GML, GML3, CITYGML, GPKG, LAS, LAZ, 3DS, GLB, PLY, STL, OBJ, OFF, USD, USDC, USDZ, AMF, 3MF, L5X, PMTILES, MBTILES, RDF, OWL, TTL, TRIG, NT, NQ, N3, JSONLD, JPEG, JPG, PNG, WebP, GIF, BMP, SVG, SVGZ, TTF, OTF, TTC, WOFF, WOFF2, CLASS, DEX, HTML, HTM, XML, SGML, CSV, TSV, IIF, ICSV, TXT, DEF, DIC, IN, LIST, NWS, IFB, MIME, TEXT, MD, MARKDOWN, QMD, MDX, RMD, ADOC, ASCIIDOC, ORG, TEXI, TEXINFO, TEX, RST, INFO, POD, MAN, ME, MS, NFO, TYP, JSON, JSON5, JSONL, NDJSON, CANVAS, YAML, YML, TOML, HCL, TF, TFVARS, INI, CONF, LOG, ENV, LOCK, DOCKERFILE, CONTAINERFILE, CFG, REG, BASE, JS, MJS, CJS, PY, PL, RB, GO, RS, C, H, CPP, CC, CXX, HH, CS, JAVA, PHP, JSX, TSX, VUE, SVELTE, ASM, S, CSS, SCSS, SASS, LESS, SH, BASH, KSH, PS1, BAT, GRAPHQL, GRAPHQLS, WSDL, RAML, PROTO, THRIFT, CAPNP, FBS, AVSC, DUMP, SQL, HAR, SRT, SBV, VTT, ASS, SSA, TTML, DFXP, ICS, MT940, OFX, QFX, QBO, QBX, RIS, BIB, BBL, ENW, NBIB, MEDLINE, QIF, DSL, STAR, POR, USDA, MBOX, MOL, SDF, SMI, MOL2, GLTF, WRL, DAE, X3D, IFC, INP, FOAM, MSH, VTK, HL7, EDIFACT, XBRL, PEM, CRT, CER, WAT, WAST, TFSTATE, GBR, PLIST, STRINGS, PBXPROJ, V, SV, SVH, VHD, VHDL, HEX, IHX, INO, WIRING, STEP, STP, IGES, IGS, MIF, DXF, KICAD, KICAD_SCH, KICAD_PCB, KICAD_SYM, KICAD_MOD, EAGLE, SCH, BRD, LBR, SCL, AWL, KML, GEOJSON, TOPOJSON, OSM, E00, MID, EPUB, MOBI, AZW, AZW3, CHM, PRC, AKN, ZIP, TAR, TGZ, 7Z, GZ, XZ, LZMA, BZ2, TBZ2, TBZ, ZST, TZST, LZ4, Z, LZH, LHA, ARJ, RAR, CBZ, CBR, WARC, WEBARCHIVE, APK, IPA, JAR, WHL, VSIX, XPI, NUPKG, KMZ, SB3, AAB, CRX, AR, DEB, IPK, UDEB, CAB, PKG, XAR, ISO, IMG, VHDX, VMDK, QCOW, QCOW2, DMG, PCAP, PCAPNG, FAISS, SAFETENSORS, GGUF, ONNX, GRO, G96, INPCRD, TOP, ITP, PRMTOP, PSF, PAR, NDX, LMP, TPR, XTC, TRR, DCD, EDR, EML, EMLX, MHT, MHTML, MSG, PST, OST, PAB. Every name in the list is the file extension itself, so a caller holding data.npy finds it there as NPY; the extension is matched without regard to case. Pass any content via the 'input' parameter - URLs are fetched, data URIs are decoded as files, and plain text is processed directly - or leave 'input' out and name the document in 'prompt' (a URL or a resource address written in it). Optional 'prompt' for LLM processing, 'result' to control output format, and 'stream' (boolean) for SSE streaming. Result is returned as an MCP content block (JSON text) containing markdown, prompt_result, parts, attachments, find, a schema answer when one was asked for, and token status; success/failure is indicated by the 'isError' flag. A file is read by the MIME declared in its data URI, not by its name, and the free tier answers with free_remaining and free_reset.","icons":[{"src":"https://mdapi.io/favicon.svg","mimeType":"image/svg+xml","sizes":["any"]}],"inputSchema":{"type":"object","properties":{"input":{"type":"string","description":"Content to convert: a URL (http(s)://...), a data URI (data:mime/type;base64,...), plain text, or a resource address (mdapi:...) returned by an earlier answer. Auto-detected: http(s):// → URL, data: → file, mdapi: → resource address, otherwise → text. A prompt that names the document - a URL or an `mdapi:` address written inside it - is used as the input when `input` is absent, so a command alone is a complete request."},"prompt":{"type":"string","description":"Custom instructions for LLM processing (e.g., 'Summarize this', 'Extract key points')"},"result":{"type":"string","enum":["markdown","prompt","both","meta"],"description":"Response format: 'markdown' (default, raw markdown), 'prompt' (LLM processed result only), 'both' (markdown + prompt_result), 'meta' (resource description only - part range, metadata, size and cost - without content)"},"stream":{"type":"boolean","description":"Enable streaming: true for SSE response"},"schema":{"type":"object","description":"Imposes the shape of the answer: the paid LLM stage answers with JSON conforming to this schema, and the answer carries it parsed in `json` beside `prompt_result` - on every protocol, since the parsed value travels with the conversion, not with one endpoint. Each protocol takes it in its own place: the request body field on REST POST and OpenAI, `?schema=` on REST GET, MCP `arguments.schema`, ACP `params.schema`, A2A `data.schema` in a message part, and on OpenAI the native `response_format.json_schema.schema` as well - the OpenAI spelling of this same parameter, so a generic OpenAI client needs no special case. Providing it without `result` implies `result=prompt`; providing it without `prompt` leaves the schema itself as the task, because its property names and descriptions say what to extract. It travels the same way on both REST methods - a JSON object in the request body on POST, the same JSON object percent-encoded in `?schema=` on GET - and gets the same checks, the same answer and the same cache entry either way, because the key names the schema itself, not the spelling that carried it. A GET answers markdown by default and answers the JSON body instead when the caller asks for it with `Accept: application/json`; a markdown body cannot carry the verdict, so a GET also reports it in `X-MDAPI-Json-Conforms` and, when the answer did not conform, `X-MDAPI-Json-Error`. It contradicts nothing silently: `result=markdown` and `stream` are refused with the reason, a keyword the service cannot honor is refused with its name instead of being ignored, and an answer that still does not conform after one repair attempt comes back whole with `jsonConforms: false` and `jsonError` naming the first violation, because the answer is knowledge and is never thrown away. Asking for JSON in words keeps working exactly as before: a `prompt` that mentions JSON is answered as JSON with no schema needed."},"json":{"type":"boolean","description":"Asks the paid stage to answer with a JSON value instead of prose. It is an input of the core, not a feature of one endpoint: it travels as the request body field `json` on REST POST and OpenAI, as `?json=true` on REST GET, as `arguments.json` on MCP, `params.json` on ACP and `data.json` in an A2A message part, and on OpenAI the native `response_format: {\"type\": \"json_object\"}` is the same request in that protocol's spelling, so a generic OpenAI client needs no special case. It changes the shape of the answer, never what is read from the document, and it needs an answer to shape: without `prompt` and without `schema` it asks for nothing and changes nothing, and a request that carries a `prompt` with `result=markdown` is refused instead of silently ignored. `schema` is the stricter request and already implies it. Asking in words keeps working exactly as before - a `prompt` that mentions JSON is answered as JSON with no flag. Because a JSON answer and a prose answer to one prompt are two different answers, the flag is part of the result cache key when it is on; when it is off the key is unchanged."},"part":{"type":"string","description":"Parts of the document to convert, 1-based: '3', '1-5' or '1-5,8'. A part is the document's natural boundary - page (PDF), slide (Presentations (PPTX, PPT, POT, PPS, ODP)), sheet (Spreadsheets (XLSX, XLS, XLSM, XLSB, ODS, ET, Numbers, DTA)), chapter (Books - EPUB and the archives (ZIP, TAR, 7z, and the compression family once it is unwrapped)) - or about 2500 characters (one A4 sheet) of a format with no such boundary. The count and unit come back in the response's `parts` field and in the `X-MDAPI-Parts` / `X-MDAPI-Part-Unit` headers; each part carries the document's front matter. Out of range is an error, never a clamp. `part` also decides how a resource larger than the input gate is read: DOCX, XLSX, XLSM, XLSB, PPTX, ODT, ODS, ODP, EPUB - By the extension alone; PDF - By the extension alone; ZIP, TAR, 7z - With `part` or `result=meta`; GZ, XZ, LZMA, BZ2, ZST, LZ4, Z and `.tar.*` - Not addressable; DOC, XLS, PPT (legacy binary office) - Not addressable; File mode (data URI) - Not addressable"},"ttl":{"type":"integer","description":"The cache is opened by asking for it. A named `ttl` is the caller's own lease: the converted markdown is kept for that lifetime, honored as named up to the one-year ceiling on the paid tier and up to one day (86400 seconds) on the free testing tier; an identical request inside the window is answered without re-converting it, and reuse never extends it. Without `ttl` a paid request stores nothing at all - the document is converted, the answer returned, and no copy is kept, so a paying caller is never the reason something is held. The free testing tier keeps a one-day entry instead (the documentation examples the same), and a repeat neither extends nor shortens it: everything that tier holds lives at most a day, because that tier is meant for testing, not for production documents. `ttl=0` stores nothing. Reading a resource address is asking to read, and needs no `ttl`. A request that carries a `password` is never cached: it neither reads a stored conversion nor stores one, so a document that was unlocked with a secret is never handed to a caller who did not name the same secret."},"capacity":{"type":"string","enum":["low","medium","high","max"],"description":"Working window of the paid LLM stage, symmetric in input and output tokens: `low` (the smallest window, the one the minimum price buys, and the default), `medium`, `high`, or `max` - the whole selected input. Each step is charged the price of its own window and bounds both sides of one model call - what is sent to the model and how long its answer may be. The document markdown a caller receives is never cut."},"attachments":{"type":"string","description":"Deliver the images embedded in the document: 'all' takes every image the answer's markdown names, a selection ('1,4-5') takes those ids only, ordered by the document. Inline in the markdown as data URIs; a temporary link per image when 'ttl' is set. Each is described by an entry carrying its name, type, size, the part it stands in and - when the format allows - its pixel size and source position, so an image can be triaged before it is transferred or looked at. An id outside the answer is an error naming the real count"},"ocr":{"type":"string","description":"Paid vision pass over the images the answer's markdown names: 'all' or a selection of ids ('1,4-5'). Each selected image is read as its own conversion and the recognized text is printed in the markdown under the image's placeholder; the main conversion is unchanged. Independent of 'attachments' - take the bytes without reading them, or read them without taking the bytes. Answered on the paid tier only: the free tier gets the payment terms instead of a spent call"},"find":{"type":"string","description":"Search the converted document for literal substrings (case-insensitive, no wildcards, no regular expressions) and answer with the ADDRESSES of their matches - the part number and the offset inside that part - never the matched text. Whitespace separates terms, and a hit is then a part where every term occurs, in any order, so 'pay court' answers the parts carrying both; with several terms 'terms[]' says how many of the searched parts carry each one. A needle longer than 256 characters, or carrying more than 8 distinct terms, is refused by name rather than answered with no matches. Read one with `part=N`. Scope the search with `part`, and the reported part numbers stay absolute. It is a conversion like any other: the resource is fetched, converted and accounted for, so it costs what the same request without `find` costs, and the saving is the caller's context. Use `result=meta` for the part listing without returning content"},"select":{"type":"string","description":"Converts the part of the document the selector names, so a page's navigation, banners and footer never reach the answer. The grammar follows the container, because a subtree is named by what it holds: an HTML or XML document holds elements, a JSON document holds keys. On HTML and XML the selector is deliberately a subset of CSS selectors rather than a CSS engine - a tag (`article`), a class (`.content`), an id (`#main`), those combined on one element (`article.content`), a descendant chain (`main article`) and a list separated by commas - matched by local name, so `item` names `atom:item` in a namespaced document; anything outside that grammar is refused with its own name instead of being ignored. On JSON the same parameter is a key path - a key (`items`), a chain of keys (`data.items`), an index (`items[0]`) or `[*]` for every member of an array or object (`items[*].title`) - and the selected subtree is returned as JSON; the dotted spelling (`items.0`, `items.*`) reads the same way and shares the same cache entry. A selector valid in both readings is kept in both and resolved by the input format at conversion time. What to keep is the caller's choice, so the service never scores or guesses the main content, and a selector that does not help is refused by name rather than answered with an empty body: the `400` says which it is - the selector names nothing in this document, or it names an element that carries no text - and always repeats the selector. A selector of one grammar on a document of the other is refused by name too, with the format and the applicable grammar stated. Other formats are refused with the format named rather than converted whole. The document's title and description still head the answer when it has them. `part` and `find` then describe the selection, not the document: the part numbering and the search run over the subtree the selector named. The selection is part of the cache key, because a selected document and the whole document are two different answers. It travels as `?select=` on REST GET and as the body field `select` on REST POST and OpenAI, and through the same argument slot on MCP, ACP and A2A. A SafeTensors weight file holds a table of tensors, so there `select` takes a tensor name: the exact name (`model.embed_tokens.weight`), a `*` pattern, or an unqualified tail (`weight`) when exactly one tensor carries it - a name that matches more than one tensor is refused with the candidates instead of resolved by picking one. The answer is that tensor's values as a table, in the dtype the file stores them, bounded to 256 rows by 64 columns; the window is stated in the answer together with the size of what it leaves out, so a large tensor is a named cut and never a silent truncation. A tensor whose header and data disagree, or whose dtype this reader does not decode, is refused by name rather than printed as numbers it does not hold."},"token":{"type":"string","description":"Access token for paid tier (optional)"},"memo":{"type":"string","description":"Payment reference required for token activation (use once with token)"},"password":{"type":"string","description":"Password that opens a locked payload (ZIP, PDF, 7z, encrypted office). A credential: it is used and dropped, never stored, never logged, never part of a cache key. A locked payload with no password answers `password_required`, one with a wrong password answers `wrong_password` - both 415, neither spends a paid call"}}},"outputSchema":{"type":"object","properties":{"markdown":{"type":"string","description":"Converted markdown content"},"prompt_result":{"type":"string","description":"LLM processed result (if prompt was provided)"},"parts":{"type":"object","description":"The part range of this answer. Present when the resource can be split; the same count and unit travel as the X-MDAPI-Parts and X-MDAPI-Part-Unit response headers.","properties":{"count":{"type":"integer","description":"How many parts the document has - the range `part` accepts"},"unit":{"type":"string","enum":["page","slide","sheet","chapter","a4"],"description":"What one part is - decided by the format, so it is the same for every caller. page: PDF; slide: Presentations (PPTX, PPT, POT, PPS, ODP); sheet: Spreadsheets (XLSX, XLS, XLSM, XLSB, ODS, ET, Numbers, DTA); chapter: Books - EPUB and the archives (ZIP, TAR, 7z, and the compression family once it is unwrapped); a4: Anything else with a text layer and no natural boundary - DOCX, DOC, ODT, RTF, text and code, CSV/TSV, JSON/YAML, HTML, images."},"listed":{"type":"array","items":{"type":"string"},"description":"A book's inventory in document order. Can name more entries than `count`: a clamped book keeps its whole listing, so the tail is listed but not addressable"},"truncated":{"type":"boolean","description":"The document was cut while it was built: an archive entry cap, a reader's own cap (rows, cells, slides, text) or the output budget. The answer carries the beginning of the real content, never a fabricated tail. Present only when true"},"names":{"type":"array","items":{"type":"string"},"description":"result=meta only: the title of each part"},"sizes":{"type":"array","description":"result=meta only: the size of each part","items":{"type":"object","properties":{"chars":{"type":"integer"},"tokens":{"type":"integer"},"bytes":{"type":"integer"}}}}}},"attachments":{"type":"array","description":"Present when the request asked for images (`attachments=all` or a selection) and the resource carries images: one entry per image, described well enough to decide which one is worth fetching or looking at. The image bytes themselves are in the markdown, not here.","items":{"type":"object","description":"One embedded image of the resource, described well enough to triage it before it is transferred or looked at. Returned when the request asked for images (`attachments=all` or a selection); each field is present only when the format let us know it.","properties":{"name":{"type":"string","description":"The image's own name when the document carries one, otherwise its img-N placeholder (the same string the markdown uses as alt text)"},"mimeType":{"type":"string","description":"The image type"},"size":{"type":"integer","description":"Length in bytes - what fetching this one image would transfer"},"placeholder":{"type":"string","description":"The img-N token this entry replaced in the markdown; its reference is an inline data URI, or the url below when ttl is set"},"part":{"type":"integer","description":"The part this image stands in, counted by the same boundaries `part` accepts, so `part=N` is exactly the request that brings this image. Absent for an archive read by parts, whose chapters are numbered by the archive and not by the markdown the request received. An image the document reuses carries the part it first appears in"},"width":{"type":"integer","description":"Pixel width read from the image header. Absent when the header could not be read; present together with height or not at all"},"height":{"type":"integer","description":"Pixel height read from the image header"},"units":{"type":"array","description":"Where the image sat in the source. Absent when the position is unknown; one image reused on several pages carries several units","items":{"type":"object","properties":{"kind":{"type":"string","enum":["slide","sheet"]},"index":{"type":"integer"},"name":{"type":"string"}}}},"url":{"type":"string","description":"Link mode only (an explicit ttl): the temporary GET /att/{id} link. Inline mode carries neither this nor expiresAt - the bytes are already in the markdown"},"expiresAt":{"type":"string","description":"Link mode only: when the url stops working"}}}},"find":{"type":"object","description":"Present when the request carried `find`: the addresses of every match, never the text. Each match is a literal substring, matched without regard to case. Whitespace inside `find` separates terms, and then a hit is a part that carries all of them, in any order. The answer is the same shape whatever else was asked for - `find` decides the answer, so `result` does not apply to it.","properties":{"needle":{"type":"string","description":"The search string that was given to `find`, trimmed"},"terms":{"type":"array","description":"Present with more than one term, and only when the answer is complete: one entry per term, in the order given, saying how many of the searched parts carry it - what tells a term that is nowhere from a term that is everywhere. A part count is a count of parts, not of occurrences; the per-hit counts are in `hits[].terms`","items":{"type":"object","properties":{"needle":{"type":"string","description":"The term as it was given"},"parts":{"type":"integer","description":"How many of the parts searched carry this term; 0 means the term itself is what left the answer empty"}}}},"matches":{"type":"integer","description":"How many matches the answer carries; 0 is an honest empty answer, not an error. With one term that is the number of occurrences, with several it is the number of parts where they meet. Capped at 100"},"hits":{"type":"array","description":"One entry per match, in document order. Each address can be read with `part=N` and then sliced at `offset`","items":{"type":"object","properties":{"part":{"type":"integer","description":"The part the match sits in - the same 1-based numbering `part` accepts and `parts.count` describes, absolute even when the request itself was scoped by `part`. Front matter belongs to part 1"},"offset":{"type":"integer","description":"0-based character offset of the match from the start of that part. With one term it is that occurrence; with several it is the earliest of the terms, the way into that part. Part 1 counts from the start of the document, so the front matter it carries is numbered before its first chapter"},"terms":{"type":"array","description":"Present with more than one term: one entry per term, in the order given, so a part found by one term can be read for how strongly it answers the others","items":{"type":"object","properties":{"needle":{"type":"string","description":"The term as it was given"},"count":{"type":"integer","description":"How many times, without overlapping, this term occurs in this part"},"offset":{"type":"integer","description":"0-based offset of this term's first occurrence in this part, counted like the hit's own `offset`"}}}}}}},"truncated":{"type":"boolean","description":"Present only when true: these are not all the matches - the hit ceiling (100) was reached, or the document itself was cut while it was built, so more may exist further on. `terms` is withheld then, so a partial count is never read as a total"}}},"json":{"type":["object","array","string","number","boolean","null"],"description":"The parsed answer, present when the request named `schema` and the answer conforms to it. Absent when the answer did not conform: the answer itself is then still served whole in `prompt_result`, and `jsonError` says why"},"jsonConforms":{"type":"boolean","description":"The verdict on a `schema` answer: true when `json` is present, false when the answer came back whole but did not conform after one repair attempt"},"jsonError":{"type":"string","description":"The first violation of the named `schema` - the path and what was expected there - present with `jsonConforms: false`"},"warnings":{"type":"array","items":{"type":"string"},"description":"Present only when the answer is usable but qualified. 'unrendered-template': the source is a page whose text is assembled by client-side JavaScript, so the markup did not carry it - either unrendered template markup, or almost no text at all where a browser check or a script-built shell stands. The markdown may therefore be a shell rather than the content. The same value is sent in the X-MDAPI-Content-Warning header"},"error":{"type":"string","description":"Present instead of content when the conversion failed. Branch on `code`, never on this text"},"code":{"type":"string","description":"Stable machine-readable error code, present with `error`"},"source":{"type":"object","description":"Present on a 502: what the source did when the service asked it for the URL. The status the service answers with stays its own - a source that answers 404 does not make the response a 404, because the service's endpoint was reached and did its work; the failure is on the far side. The body of the source's own error page is not passed through: it is untrusted third-party content and does not belong in a caller's context. Nothing is charged.","properties":{"url":{"type":"string","description":"The address the service actually fetched, after any redirects - the caller's own URL unless the source redirected it"},"status":{"type":["integer","null"],"description":"The HTTP status the source answered with, as a number. null when the source never answered at all"},"status_text":{"type":["string","null"],"description":"The reason phrase that came with that status, exactly as the source wrote it (e.g. 'Not Found'). null when there was no answer"},"reason":{"type":"string","enum":["source_answered","timeout","network_error"],"description":"Which failure this was: source_answered (the source replied with a non-success status), timeout (no answer within the fetch timeout) or network_error (the connection failed)"},"retryable":{"type":"boolean","description":"Whether asking again for this same URL can succeed. false means the source has given its verdict and a repeat gets the same answer - a different address or document is needed. true for a 5xx, for the 4xx that ask for a pause (408, 425, 429) and for a source that never answered"}}},"token_status":{"type":"string","description":"Token status"},"token_balance":{"type":"number","description":"Remaining token balance in USD (monetary, fractional; e.g. 0.99)"},"token_expires":{"type":"integer","description":"Token expiry timestamp"},"free_remaining":{"type":"integer","description":"How many free conversions are left to this caller today, counted after the one being answered. The free tier carries 10 conversions a day to a caller, within a quota allocated for the whole service, so the full allowance is not guaranteed"},"free_reset":{"type":"integer","description":"Unix timestamp when the free allowance is restored: the start of the next day (UTC)"}}},"annotations":{"readOnlyHint":false,"destructiveHint":false,"idempotentHint":true,"openWorldHint":true}}],"resources":[{"uri":"https://mdapi.io/about","name":"About service","mimeType":"text/markdown","description":"What the service is, what it transforms and how it is paid for."},{"uri":"https://mdapi.io/privacy","name":"Privacy","mimeType":"text/markdown","description":"What a request leaves behind: the conversion when it is asked for, a token balance, and counts that carry no document."},{"uri":"https://mdapi.io/contact","name":"Contact","mimeType":"text/markdown","description":"Where to write: the repository, and the security contact a scanner reads from the security.txt file."},{"uri":"https://mdapi.io/AGENTS.md","name":"Agent entry point","mimeType":"text/markdown","description":"Where an autonomous agent starts: the one call, the protocols and the documents to read next."},{"uri":"https://mdapi.io/auth.md","name":"Agent access","mimeType":"text/markdown","description":"How an agent obtains access and keeps it: the payment answer, the token and the operations on it."},{"uri":"https://mdapi.io/mcp","name":"MCP server manifest","mimeType":"application/json","description":"Model Context Protocol server manifest."},{"uri":"https://mdapi.io/health","name":"Health check","mimeType":"application/json","description":"Service health and the endpoint catalog."},{"uri":"https://mdapi.io/llms.txt","name":"Documentation index","mimeType":"text/plain","description":"Short llmstxt.org index linking the full documentation, the specifications and every discovery manifest."},{"uri":"https://mdapi.io/llms-full.txt","name":"Full API documentation","mimeType":"text/plain","description":"Complete AI-readable reference: parameters, formats, limits and error codes."},{"uri":"https://mdapi.io/.well-known/ai-discovery.json","name":"AI discovery","mimeType":"application/json","description":"Unified discovery manifest: every protocol, capability and route in one document."},{"uri":"https://mdapi.io/.well-known/agent.json","name":"AI Agent discovery","mimeType":"application/json","description":"Service metadata and integration endpoints for agent frameworks."},{"uri":"https://mdapi.io/.well-known/agent-card.json","name":"A2A Agent card","mimeType":"application/json","description":"Google A2A protocol agent card: capabilities, skills and transport."},{"uri":"https://mdapi.io/.well-known/acp.json","name":"ACP manifest","mimeType":"application/json","description":"Agent Client Protocol manifest: version, methods and transports."},{"uri":"https://mdapi.io/.well-known/x402.json","name":"x402 payment manifest","mimeType":"application/json","description":"x402 v2 payment manifest: schemes, price and wallet."},{"uri":"https://mdapi.io/.well-known/openapi.json","name":"OpenAPI specification (JSON)","mimeType":"application/json","description":"The OpenAPI 3.1.0 specification in JSON, for SDK generation and programmatic discovery."},{"uri":"https://mdapi.io/.well-known/openapi.yaml","name":"OpenAPI specification (YAML)","mimeType":"text/yaml","description":"The same OpenAPI 3.1.0 specification in YAML."},{"uri":"https://mdapi.io/.well-known/mapi.md","name":"MAPI specification","mimeType":"text/markdown","description":"The request and response contract of every protocol, surface by surface."},{"uri":"https://mdapi.io/.well-known/skill.md","name":"Skill specification","mimeType":"text/markdown","description":"How an agent runs a conversion, step by step."},{"uri":"https://mdapi.io/.well-known/ard.json","name":"ARD manifest","mimeType":"application/ard+json","description":"Agentic Resource Discovery manifest: the MCP server, the A2A agent, the REST API and the skill, each addressable."},{"uri":"https://mdapi.io/.well-known/plugin/plugin.json","name":"Agent Plugins manifest","mimeType":"application/json","description":"Agent Plugins (agent-plugins.org v1.0.0) portable package manifest."},{"uri":"https://mdapi.io/docs","name":"API documentation pages","mimeType":"text/markdown","description":"The API documentation split into addressable pages - the language examples and the long guides, each complete on its own."},{"uri":"https://mdapi.io/docs/examples","name":"Example pages","mimeType":"text/markdown","description":"Every example in one place - the language examples and the protocol examples, each complete on its own."}],"instructions":"Use 'convert' tool with 'input' parameter (URL, text, or data URI). Supports all formats: webpages, DOCX, DOC, DOT, WIZ, ODT, RTF, WPD, WP5, WP6, WP, DJVU, DJV, HC, STK, HWP, HWPX, UOF, UOT, SXW, IDML, ODM, DOCM, DOTX, DOTM, FODT, FOTT, OTT, ABW, ZABW, WPS, WPT, PAGES, JATS, TEI, DOCBOOK, DBK, DITA, DITAMAP, FB2, FB3, DAISY, DTBOOK, PDF, AI, XPS, OXPS, VSDX, PS, EPS, DVI, ENEX, FDX, MUSICXML, MXL, SKETCH, DRAWIO, XMIND, MMAP, ODG, EMF, WMF, ONE, ONETOC2, IPYNB, NB, XLSX, XLS, XLC, XLM, XLT, XLSM, XLSB, XLA, XLTX, XLTM, XLAM, ODS, FODS, OTS, ET, ETT, PMD, GNUMERIC, Numbers, DTA, RDS, RDA, RData, NPY, NPZ, HYPER, SLK, SYLK, DIF, PRN, FWF, WK1, WK2, WK3, WK4, SXC, UOS, PPTX, PPT, PPA, POT, PPS, PWZ, POTX, POTM, PPSX, PPSM, PPTM, DPS, DPT, ODP, FODP, OTP, KEY, SXI, UOP, DBF, FPT, DBT, ODB, MSI, BSON, BED, BEDGRAPH, BB, NARROWPEAK, BROADPEAK, GTF, GFF, GFF2, GFF3, FASTA, FA, FFN, FAA, FNA, FASTQ, FQ, GB, GBK, GBFF, EMBL, SAM, VCF, NEWICK, NEXUS, CIF, MMCIF, PDB, ENT, XYZ, NII, FITS, MRC, MRCS, EDF, BDF, NRRD, TIFF, TIF, GeoTIFF, DCM, JCAMP-DX, JDX, DX, JCAMP, NetCDF, NC, CDF, MZML, MZXML, CBF, MAP, MTZ, SAV, ZSAV, XPT, MAT, DM3, DM4, PARQUET, PQ, AVRO, ORC, ARROW, FTR, FEATHER, ARROWS, LANCE, SQLITE, DB, SQLITE3, MDB, ACCDB, DUCKDB, SAS7BDAT, TWB, TWBX, PBIX, HDF5, H5, HE5, HDF, MNC, NXS, SHP, GPX, GML, GML3, CITYGML, GPKG, LAS, LAZ, 3DS, GLB, PLY, STL, OBJ, OFF, USD, USDC, USDZ, AMF, 3MF, L5X, PMTILES, MBTILES, RDF, OWL, TTL, TRIG, NT, NQ, N3, JSONLD, JPEG, JPG, PNG, WebP, GIF, BMP, SVG, SVGZ, TTF, OTF, TTC, WOFF, WOFF2, CLASS, DEX, HTML, HTM, XML, SGML, CSV, TSV, IIF, ICSV, TXT, DEF, DIC, IN, LIST, NWS, IFB, MIME, TEXT, MD, MARKDOWN, QMD, MDX, RMD, ADOC, ASCIIDOC, ORG, TEXI, TEXINFO, TEX, RST, INFO, POD, MAN, ME, MS, NFO, TYP, JSON, JSON5, JSONL, NDJSON, CANVAS, YAML, YML, TOML, HCL, TF, TFVARS, INI, CONF, LOG, ENV, LOCK, DOCKERFILE, CONTAINERFILE, CFG, REG, BASE, JS, MJS, CJS, PY, PL, RB, GO, RS, C, H, CPP, CC, CXX, HH, CS, JAVA, PHP, JSX, TSX, VUE, SVELTE, ASM, S, CSS, SCSS, SASS, LESS, SH, BASH, KSH, PS1, BAT, GRAPHQL, GRAPHQLS, WSDL, RAML, PROTO, THRIFT, CAPNP, FBS, AVSC, DUMP, SQL, HAR, SRT, SBV, VTT, ASS, SSA, TTML, DFXP, ICS, MT940, OFX, QFX, QBO, QBX, RIS, BIB, BBL, ENW, NBIB, MEDLINE, QIF, DSL, STAR, POR, USDA, MBOX, MOL, SDF, SMI, MOL2, GLTF, WRL, DAE, X3D, IFC, INP, FOAM, MSH, VTK, HL7, EDIFACT, XBRL, PEM, CRT, CER, WAT, WAST, TFSTATE, GBR, PLIST, STRINGS, PBXPROJ, V, SV, SVH, VHD, VHDL, HEX, IHX, INO, WIRING, STEP, STP, IGES, IGS, MIF, DXF, KICAD, KICAD_SCH, KICAD_PCB, KICAD_SYM, KICAD_MOD, EAGLE, SCH, BRD, LBR, SCL, AWL, KML, GEOJSON, TOPOJSON, OSM, E00, MID, EPUB, MOBI, AZW, AZW3, CHM, PRC, AKN, ZIP, TAR, TGZ, 7Z, GZ, XZ, LZMA, BZ2, TBZ2, TBZ, ZST, TZST, LZ4, Z, LZH, LHA, ARJ, RAR, CBZ, CBR, WARC, WEBARCHIVE, APK, IPA, JAR, WHL, VSIX, XPI, NUPKG, KMZ, SB3, AAB, CRX, AR, DEB, IPK, UDEB, CAB, PKG, XAR, ISO, IMG, VHDX, VMDK, QCOW, QCOW2, DMG, PCAP, PCAPNG, FAISS, SAFETENSORS, GGUF, ONNX, GRO, G96, INPCRD, TOP, ITP, PRMTOP, PSF, PAR, NDX, LMP, TPR, XTC, TRR, DCD, EDR, EML, EMLX, MHT, MHTML, MSG, PST, OST, PAB. Every name in the list is the file extension itself, so a caller holding data.npy finds it there as NPY; the extension is matched without regard to case. Optional 'prompt' for LLM processing (e.g., 'Summarize', 'Extract entities') and 'result' to control output - one of 'markdown', 'prompt', 'both', 'meta', each described in the tool schema. Result is an MCP content block (JSON text) with markdown, prompt_result, token_status, token_balance, and token_expires; use the 'isError' flag to detect failures. Free tier available, within the service's overall free quota. Paid tier at min $0.01/request via x402 protocol. IMPORTANT: Paid tokens must be activated first with memo before use.","tokenActivation":{"description":"Paid token flow: get 402, pay, retry with token+memo","steps":["Request without token → 402 with NEW token+memo","Pay USDC to wallet with memo from 402","Retry with token+memo from 402 → activated","After: use token only"],"examples":{"activate":"curl -X POST https://mdapi.io/mcp -H 'Content-Type: application/json' -H 'MCP-Protocol-Version: 2026-07-28' -H 'Mcp-Method: tools/call' -H 'Mcp-Name: mdapi' -d '{\"jsonrpc\":\"2.0\",\"id\":1,\"method\":\"tools/call\",\"params\":{\"name\":\"convert\",\"arguments\":{\"input\":\"https://example.com\",\"token\":\"TOKEN\",\"memo\":\"MEMO\"}}}'","useActivated":"curl -X POST https://mdapi.io/mcp -H 'Content-Type: application/json' -H 'MCP-Protocol-Version: 2026-07-28' -H 'Mcp-Method: tools/call' -H 'Mcp-Name: mdapi' -d '{\"jsonrpc\":\"2.0\",\"id\":2,\"method\":\"tools/call\",\"params\":{\"name\":\"convert\",\"arguments\":{\"input\":\"https://example.com\",\"token\":\"TOKEN\"}}}'"}}}