MIDAS products

DocMint documentation hub

DocMint: SEC Filings, HTML, Word, Excel & PPTX to Markdown

Local-tested — not production-verified on Apify, not market-validated. Live usage metrics are unavailable. Status is v0.2.0, unreleased.

Turn SEC filings (HTML / inline XBRL), web pages and Office files (Word, Excel, PowerPoint) into clean, LLM-ready Markdown and structured tables in one run. Text-based PDFs are supported too. Pay only for what converts. Approved public pricing is Model C: $0.008 per document + $0.004 per billable page.

What it is built for — and what it does not claim

Guides: SEC filing to Markdown, Word to Markdown, text-based PDFs to Markdown, Markdown for RAG, Model C worked examples.

Model C pricing and the 3,000-character page-equivalent rule

Every successfully converted document is billed $0.008 (document-processed) plus $0.004 per billable page (page-processed). Failed documents, documents skipped by limits or the safety breaker, and image-only PDFs with no text layer, cost $0. You never receive pages you were not charged for, and you never pay for pages you did not receive.

A billable page is:

The math below uses only that rule and Model C rates. Figures are exact.

InputBillable pagesDocument feePage feesTotal
1-page text-based PDF1$0.008$0.004$0.012
10-page text-based PDF10$0.008$0.040$0.048
30,000-character DOCX or HTML (including an SEC filing)10$0.008$0.040$0.048
3,001-character DOCX or HTML2$0.008$0.008$0.016
Short DOCX or HTML (minimum 1 page)1$0.008$0.004$0.012
XLSX with 2 small sheets2$0.008$0.008$0.016
Workbook with three small sheets (minimum 1 page each)3$0.008$0.012$0.020
One 60,000-character sheet (60,000 ÷ 3,000 = 20)20$0.008$0.080$0.088
Failed document, or image-only PDF with no text layer0$0$0$0

maxPagesPerDocument (default 200, maximum 500) caps billable pages per document. A run-level maximum charge also caps output: the last document is cut to the pages that fit, with a warning, and the run then stops.

Safety limits (local-tested, not production-verified on Apify)

The Actor code includes a per-document processing limit of 120 seconds (or a memory cap), and a safety breaker that cannot be turned off: the run stops after 3 documents in a row hit that limit (configurable via breakerConsecutiveLimit, default 3), or once limit-hit documents exceed 20% of attempted documents, checked from the 5th attempted document (breakerFailurePercent, default 20). Remaining documents get a skipped row and cost $0. These behaviors were exercised in local security and billing tests on 19 November 2026 (see the project’s SECURITY notes). They have not been production-verified on the Apify platform.

Actor inputs and outputs

Inputs (from the Actor input schema): documents (public http(s) URLs), base64Documents ({filename, data, contentType} for API uploads), extractTables (default true), includePages (default false), maxPagesPerDocument (default 200), breakerConsecutiveLimit (default 3), breakerFailurePercent (default 20).

Each output row includes markdown, text, tables (rows, CSV and Markdown, with page or sheet), optional per-page pages, billable_pages, metadata, status, and warnings.

Integration quickstart

The Actor is not published on the Apify Store as of 20 November 2026. Set DOCMINT_ACTOR_ID to the published Actor id after the first Store publish. The sample URL below is the public IRS W-9 PDF used in the project’s own input prefill. The same input shape accepts a public SEC HTML filing URL.

Apify API

import { ApifyClient } from "apify-client";

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor(process.env.DOCMINT_ACTOR_ID).call({
  documents: [{ url: "https://www.irs.gov/pub/irs-pdf/fw9.pdf" }],
  extractTables: true,
  includePages: false,
  maxPagesPerDocument: 200,
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
for (const item of items) {
  // item.markdown, item.text, item.tables, item.billable_pages, item.warnings, item.status
  console.log(item.status, item.billable_pages);
}

n8n

Use n8n’s Apify integration (or an HTTP Request node) to start the Actor with the same input fields: documents or base64Documents, plus any of extractTables, includePages, and maxPagesPerDocument. In a later node, read the default dataset and map markdown, tables, and billable_pages. Make and Zapier can call the same Actor through their Apify integrations using the same input object. These recipes assume the Actor id is available after publish; they have not been production-verified against a live Store listing.

LangChain

from langchain_core.documents import Document

# `items` is the Actor dataset: each row has markdown, text, tables, billable_pages, warnings
docs = [
    Document(
        page_content=item["markdown"],
        metadata={
            "source": item.get("source"),
            "billable_pages": item.get("billable_pages"),
            "status": item.get("status"),
        },
    )
    for item in items
    if item.get("status") == "ok" and item.get("markdown")
]

LlamaIndex

from llama_index.core import Document, VectorStoreIndex

documents = [
    Document(
        text=item["markdown"],
        metadata={
            "source": item.get("source"),
            "billable_pages": item.get("billable_pages"),
        },
    )
    for item in items
    if item.get("status") == "ok" and item.get("markdown")
]
index = VectorStoreIndex.from_documents(documents)

There is no first-party DocMint LangChain or LlamaIndex package. The snippets wrap the real Actor output fields only.

Join a documentation waitlist

If you want a note when the Apify Store listing is published, leave an email. This is optional and is not a paid signup.

See the site privacy notice.