# com.docimprint/api (remote · api.docimprint.com)

AI document intelligence: extract, summarize, claim-check, notarize, and signed action receipts.

- Trust score: 73/100 (medium)
- Change this week: +5
- Registry status: active
- Liveness: live
- Owner verified: no
- Last scored: 2026-08-03

## Components

- remote · `api.docimprint.com`: 73/100 (this document), [markdown](https://verifymcp.io/servers/com-docimprint-api/api.md), [page](https://verifymcp.io/servers/com-docimprint-api/api)

## Channel facts

- Endpoint: `https://api.docimprint.com/mcp`
- Transports: `streamable-http`
- Auth: `required`
- Version: `1.0.4`

## Trust breakdown

How this component scores in each security and reliability category. Every signal is checked automatically against the live server, and we only credit what we can confirm. Scores are 0–100 per category. Scoring method: https://verifymcp.io/docs/scoring (what has changed: https://verifymcp.io/docs/scoring/changelog)

Scored 2026-08-03.

- **Endpoint Security**: 71/100
  - The endpoint's TLS certificate is valid, in date, and uses a strong key.
  - Authorisation is enforced on tool calls, but the challenge carries no valid RFC 9728 metadata, so a client cannot discover where to get a token.
  - HTTPS not yet verified: we couldn't determine whether a plaintext access path exists.
  - HSTS check failed: the Strict-Transport-Security header is absent.
  - DNSSEC check failed: this domain isn't protected by DNSSEC.
- **Transport & Reachability**: 100/100
  - Verified streamable-http transport via a live MCP handshake.
- **Schema Quality & AI Usability**: 77/100
  - 100% of prompts and resources have a non-trivial description (not blank, and not just the item's name).
  - AI-judged instruction clarity (excellent).
  - Context-footprint check failed: tool/resource definitions use about 5274 tokens (~239/item across 22 items; 22 tools + 0 resources), over budget; trim descriptions and params.
  - Usage-examples check failed: none of the tools include examples.
- **Stability & Change Management**: 27/100
  - Stability observed for 8 of 30 days with no destabilising changes; credit accrues until the full window elapses.
- **Tool Coverage**: 100/100
  - 100% of tools have a non-trivial description (not blank, and not just the tool's name).
  - 100% of tool parameters carry a description.
  - Structured output schemas are declared (100% of tools); any adoption earns full credit.
- **Capabilities**: 100/100
  - Implements a supported MCP spec version (2025-11-25); the latest is 2026-07-28.

## Install

### Claude

```bash
claude mcp add --transport http com-docimprint-api https://api.docimprint.com/mcp
```

### Codex

```toml
[mcp_servers.com-docimprint-api]
url = "https://api.docimprint.com/mcp"
```

### opencode

```json
{
  "$schema": "https://opencode.ai/config.json",
  "mcp": {
    "com-docimprint-api": {
      "type": "remote",
      "url": "https://api.docimprint.com/mcp",
      "enabled": true
    }
  }
}
```

### OpenClaw

```bash
openclaw mcp add com-docimprint-api --url https://api.docimprint.com/mcp --transport streamable-http
```

### Hermes

```yaml
mcp_servers:
  com-docimprint-api:
    url: "https://api.docimprint.com/mcp"
```

### Other

```json
{
  "mcpServers": {
    "com-docimprint-api": {
      "type": "http",
      "url": "https://api.docimprint.com/mcp"
    }
  }
}
```

The mcpServers block is a cross-client convention. Remote transports vary, so check your client's docs.

## Changelog

Every change recorded for this component, newest first. Days that predate change tracking, or that we cannot explain, say so: "we were watching and nothing happened" and "we were not watching" are different claims.

### 2026-08-03 (score 73, +1)

No change was recorded against any check on this day. Stability & Change Management went from 23 to 27. That category is still filling its 30-day observation window: 7 days of observed history at the previous scan, 8 at this one. The score rises as the window fills, whether or not the server changes.

### 2026-08-01 (score 72, +1)

No change was recorded against any check on this day. Stability & Change Management went from 17 to 20. That category is still filling its 30-day observation window: 5 days of observed history at the previous scan, 6 at this one. The score rises as the window fills, whether or not the server changes.

### 2026-07-31 (score 71, +1)

- [functional] We updated how we score, so this day's move reflects our rubric, not a change to the server

### 2026-07-30 (score 70, +1)

- [functional] We updated how we score, so this day's move reflects our rubric, not a change to the server

### 2026-07-29 (score 69, +1)

No change was recorded against any check on this day. Stability & Change Management went from 7 to 10. That category is still filling its 30-day observation window: 2 days of observed history at the previous scan, 3 at this one. The score rises as the window fills, whether or not the server changes.

### 2026-07-27 (score 68, +1)

- [functional] We updated how we score, so this day's move reflects our rubric, not a change to the server

### 2026-07-26 (score 67)

First indexed and scored.

## MCP tools (22)

### `document.extract_text` (~192 tokens)

Extract Text

Extract plain text from a PDF or image (base64-encoded). Use when you need raw text for downstream AI analysis (summarization, claim checking, structured extraction). For documents at a public URL, use url.extract instead (no base64 encoding needed).
Returns: { pages: number, text: string }
Example prompts:
\- "Extract the text from this scanned contract so I can search it."
\- "Give me the raw text from this PDF document."
\- "OCR this image and return the text content."

Input parameters:

- `document_base64` (string, required): Base64-encoded PDF or image bytes (max ~15 MB). Example: "JVBERi0xLjcNJeLjz9MNCj..." (truncated PDF base64)
- `mime_type` (string, required): MIME type of the document. Example: "application/pdf" for PDFs, "image/png" for PNG screenshots.

Output parameters:

- `pages` (number)
- `text` (string)

### `document.extract_tables` (~196 tokens)

Extract Tables

Extract tables and forms as Markdown from a PDF or image (base64-encoded). Use when the document contains structured tabular data such as financial statements, data sheets, or forms. For plain prose documents, use document.extract_text instead.
Returns: { pages: number, text: string } — text contains Markdown-formatted tables.
Example prompts:
\- "Extract the tables from this financial statement."
\- "Pull the data table from this PDF into Markdown format."
\- "Get the tabular data from this form document."

Input parameters:

- `document_base64` (string, required): Base64-encoded PDF or image bytes (max ~15 MB). Example: "JVBERi0xLjcNJeLjz9MNCj..." (truncated PDF base64)
- `mime_type` (string, required): MIME type of the document. Example: "application/pdf" for PDF bank statements, "image/jpeg" for photo of a form.

Output parameters:

- `pages` (number)
- `text` (string)

### `document.parse_invoice` (~240 tokens)

Parse Invoice

Parse a receipt or invoice document into structured fields. Uses a quality AI model for accuracy. Use when you need to extract line items, totals, and merchant info from financial documents. For general document text, use document.extract_text instead.
Returns: {
  invoice: { merchant, date (YYYY-MM-DD), line_items[], subtotal, tax, total },
  cited: { <field>: { value, confidence: "high"|"medium"|"low", citations: [{ quote, paragraphs[] }] } }
}
Example prompts:
\- "Parse this invoice and give me the line items and total."
\- "Extract the merchant, date, and amounts from this receipt."
\- "Read this scanned invoice and return structured data."

Input parameters:

- `document_base64` (string, required): Base64-encoded PDF or image of the receipt/invoice (max ~15 MB). Example: "JVBERi0xLjcNJeLjz9MNCj..." (base64-encoded invoice PDF)
- `mime_type` (string, required): MIME type of the document. Example: "application/pdf" for scanned invoice PDF, "image/jpeg" for a receipt photo.

Output parameters:

- `cited` (object)
- `invoice` (object)

### `document.check_claims` (~300 tokens)

Check Claims

Verify a list of factual claims against document text. Uses a quality AI model with citation-level evidence. Use after document.extract_text or url.extract when you need to validate specific factual assertions. For open-ended questions about a document, use url.qa instead. For multi-document investigation, use collection.ask.
Typical workflow: document.extract_text/url.extract → document.check_claims.
Returns: {
  claims: [{ claim, status: "supported"|"contradicted"|"not_found", evidence: { quote, paragraphs[] }, confidence: "high"|"medium"|"low" }],
  truncated: boolean
}
Example prompts:
\- "Check whether this contract mentions a liability cap of $1M."
\- "Verify these claims against the document: [claims list]."
\- "Does the report actually say revenue grew 23%?"

Input parameters:

- `claims` (array, required): Factual statements to verify. Each claim is checked independently against the text. Example: ["Founded in 2010", "Revenue exceeded $1M"]
- `max_tokens` (number): Input length cap (1 token ≈ 4 chars). Default ~3000 tokens. Truncates input text, not the output. Example: 4000
- `text` (string, required): Document text to check claims against. Obtain via document.extract_text or url.extract. Example: "ACME Corp was founded in 2010. Revenue exceeded $1M in 2024."

Output parameters:

- `claims` (array)
- `truncated` (boolean)

### `document.extract_structured` (~352 tokens)

Extract Structured Data

Extract typed fields from document text using a caller-defined schema. Uses a quality AI model with retry logic. Use when you need specific data points from a document rather than full text. For invoices with known fields, document.parse_invoice (prebuilt schema) may be simpler. For general summarization, use document.summarize instead.
Schema format: { "field_name": "type hint or description" } — e.g. { "contract_date": "ISO date", "party_a": "string", "penalty_usd": "number" }.
Returns: {
  data: { <field>: value },
  data_cited: { <field>: { value, confidence: "high"|"medium"|"low", citations: [{ quote, paragraphs[] }] } }
}
Example prompts:
\- "Extract the contract date, parties, and penalty amount from this agreement."
\- "Pull the vendor name, PO number, and total from this document."
\- "Get me all named fields from this form using my custom schema."

Input parameters:

- `max_tokens` (number): Input length cap (1 token ≈ 4 chars). Default ~2500 tokens. Truncates input, not output. Example: 3000
- `schema` (object, required): Field map: describe each field you want extracted with a type hint. Example: { "total_usd": "number", "vendor": "string", "invoice_date": "ISO date YYYY-MM-DD" }
- `text` (string, required): Document text to extract from. Obtain via document.extract_text or url.extract. Example: "This Service Agreement is entered into on 2025-03-15 between ACME Corp and Beta Inc..."

Output parameters:

- `data` (object)
- `data_cited` (object)

### `document.summarize` (~265 tokens)

Summarize Document

Summarize document text into a prose summary and key points with citations. Use after document.extract_text or url.extract when you need a condensed understanding of a long document. For single-sentence Q&A, use url.qa instead. For extracting specific fields, use document.extract_structured.
Typical workflow: document.extract_text/url.extract → document.summarize.
Returns: {
  summary: string,
  key_points: string[],
  summary_cited: { value, confidence, citations[] },
  key_points_cited: [{ text, citations[] }],
  truncated: boolean,
  strategy: "full"|"truncated"|"chunked"
}
Example prompts:
\- "Summarize this financial report and give me the key points."
\- "What are the main takeaways from this document?"
\- "Give me a concise summary of this 50-page report."

Input parameters:

- `max_tokens` (number): Input length cap (1 token ≈ 4 chars). Default ~3000 tokens. Truncates input, not output. Example: 4000
- `text` (string, required): Document text to summarize. Obtain via document.extract_text or url.extract. Example: "The Q4 2025 financial report shows revenue growth of 23% year-over-year..."

Output parameters:

- `key_points` (array)
- `key_points_cited` (array)
- `strategy` (string)
- `summary` (string)
- `summary_cited` (object)
- `truncated` (boolean)

### `bundle.verify` (~274 tokens)

Verify Evidence Bundle

Verify the cryptographic integrity of an evidence bundle (ev_...) owned by your API key. Checks manifest hash, EIP-191 signature, and R2 artifact hashes. Free — no credits consumed. Use when you need to confirm a bundle has not been tampered with. For quick metadata lookups (without full crypto verification), use bundle.get instead. Also returns a signed action receipt (rcpt_...) binding this verify call to the bundle manifest — list with receipt.list, verify with receipt.verify.
Returns: {
  valid: boolean,
  bundle_id, manifest_sha256,
  checks: { status, manifest_hash, signature, artifacts: [{ name, ok }] },
  tampered: string[],
  signer_address: string|null,
  attestation_tx: string|null,
  url: string, captured_at: string,
  receipt: ActionReceipt|null
}
Example prompts:
\- "Verify the cryptographic integrity of bundle ev_550e8400."
\- "Is this evidence bundle still valid and untampered?"
\- "Deep-check the manifest hash and signature of my bundle."

Input parameters:

- `bundle_id` (string, required): Evidence bundle ID (ev_...) returned by extract or notarize. Example: "ev_550e8400-e29b-41d4-a716-446655440000"

Output parameters:

- `attestation_tx`
- `bundle_id` (string)
- `captured_at` (string)
- `checks` (object)
- `manifest_sha256`
- `receipt`
- `signer_address`
- `tampered` (array)
- `url` (string)
- `valid` (boolean)

### `collection.create` (~167 tokens)

Create Collection

Create a named document collection for cross-document semantic search and RAG-based Q&A. Free — no credits consumed. Use when you want to group related evidence bundles for unified search (collection.search) or question answering (collection.ask).
NOTE: Collections start empty. Add evidence bundles with collection.add_document. Indexing is async — once complete, use collection.search or collection.ask.
Returns: { collection_id: string (col_...), name: string }
Example prompts:
\- "Create a collection called Q4 Contracts for my quarterly reports."
\- "Set up a new document group named Due Diligence Docs."
\- "Make a collection to organize my vendor agreements."

Input parameters:

- `name` (string, required): Human-readable collection name. Example: "Q4 Contracts" or "Due Diligence Docs"

Output parameters:

- `collection_id` (string)
- `name` (string)

### `collection.search` (~244 tokens)

Search Collection

Semantic (vector) search across documents in a collection. Returns ranked text chunks with relevance scores. Free — no credits consumed. Use when you need raw matching chunks from a collection. For a synthesized cited answer from the same context, use collection.ask instead.
PREREQUISITE: Collection must be populated via collection.add_document and async indexing must complete (poll job.status) before results appear.
Returns: { results: [{ bundle_id, chunk_id, text, score: number (0–1), title? }] }
Example prompts:
\- "Search my Q4 Contracts collection for mentions of liability cap."
\- "Find the clause about data retention in my due diligence docs."
\- "Search for revenue numbers across my quarterly reports."

Input parameters:

- `collection_id` (string, required): Collection ID (col_...) returned by collection.create. Example: "col_550e8400-e29b-41d4-a716-446655440000"
- `limit` (number): Max chunks to return (default 10, max 50). Example: 5
- `query` (string, required): Natural language search query. Example: "What were the revenue numbers for Q4?"

Output parameters:

- `results` (array)

### `collection.ask` (~272 tokens)

Ask Collection

Answer a question using RAG over a document collection. Retrieves relevant chunks then synthesizes a cited answer with source attribution. Use when you need a direct answer grounded in your collection documents. For raw matching chunks (without synthesis), use collection.search instead. For single-document Q&A, use url.qa instead.
PREREQUISITE: Collection must be populated via collection.add_document and indexed before results appear.
Returns: {
  answer: string,
  sources: [{ bundle_id, chunk_id }],
  retrieval: [{ bundle_id, chunk_id, text, score }]
}
Example prompts:
\- "What are the key terms of the service agreement in my collection?"
\- "Based on my due diligence docs, what are the main risks?"
\- "Answer this question using all documents in the Q4 Contracts collection."

Input parameters:

- `collection_id` (string, required): Collection ID (col_...) returned by collection.create. Example: "col_550e8400-e29b-41d4-a716-446655440000"
- `max_chunks` (number): Max chunks to retrieve for context (default 8). Increase for broad questions, decrease for precision. Example: 12
- `question` (string, required): Natural language question to answer from collection documents. Example: "What are the key terms of the service agreement?"

Output parameters:

- `answer` (object)
- `retrieval` (array)
- `sources` (array)

### `url.extract` (~175 tokens)

Extract Text from URL

Fetch a public HTTPS URL and return extracted text and page metadata. Lean mode — no evidence bundle stored, no bundle_id returned. Use for raw text extraction from web pages and online documents. Use url.summarize for summaries, url.qa for Q&A, url.translate for translation, document.extract_text for base64 file uploads.
Returns: { url, title, word_count, text, final_url (after redirects) }
Example prompts:
\- "Extract the text from https://example.com/report.pdf for me."
\- "Get me the raw content of this web page: [URL]."
\- "Pull the text from this online article so I can analyze it."

Input parameters:

- `url` (string, required): Public HTTPS URL to fetch and extract. Example: "https://example.com/report.pdf" or "https://blog.example.com/article"

Output parameters:

- `final_url` (string)
- `text` (string)
- `title` (string)
- `url` (string)
- `word_count` (number)

### `url.summarize` (~200 tokens)

Summarize URL

Fetch a public HTTPS URL and return a prose summary with key points. Lean mode — no bundle stored. Use when you need a condensed understanding of a web page. For raw text, use url.extract. For asking a specific question about a page, use url.qa.
Returns: { url, summary, key_points: string[], truncated: boolean, word_count }
Example prompts:
\- "Summarize https://en.wikipedia.org/wiki/Artificial_intelligence for me."
\- "Give me the key points from this blog post: [URL]."
\- "What is this article about? Summarize [URL]."

Input parameters:

- `max_tokens` (number): Input length cap (1 token ≈ 4 chars). Truncates fetched page content, not the output summary. Example: 4000
- `url` (string, required): Public HTTPS URL to fetch and summarize. Example: "https://en.wikipedia.org/wiki/Artificial_intelligence"

Output parameters:

- `key_points` (array)
- `summary` (string)
- `truncated` (boolean)
- `url` (string)
- `word_count` (number)

### `url.qa` (~232 tokens)

Ask a Question About a URL

Fetch a public HTTPS URL and answer a specific question about its content. Lean mode — no bundle stored. Use when you have a precise question about a web page. For a broad summary, use url.summarize. For multi-document Q&A, use collection.ask instead.
Returns: { url, answer, answer_cited: { value, confidence, citations[] }, confidence: "high"|"medium"|"low", truncated }
Example prompts:
\- "What is the refund policy at https://docs.example.com/policy?"
\- "Look at [URL] and tell me what the delivery terms are."
\- "Answer this question based on the content of [URL]: [question]."

Input parameters:

- `max_tokens` (number): Input length cap (1 token ≈ 4 chars). Truncates fetched page content, not the answer. Example: 4000
- `question` (string, required): Specific question to answer from the page content. Example: "What is the refund policy?"
- `url` (string, required): Public HTTPS URL to fetch and question. Example: "https://docs.example.com/policy"

Output parameters:

- `answer` (string)
- `answer_cited` (object)
- `confidence` (string)
- `truncated` (boolean)
- `url` (string)

### `url.translate` (~219 tokens)

Translate URL

Fetch a public HTTPS URL and return its content translated into a target language. Lean mode — no bundle stored. Use when you need to understand web content in a different language. For extracting raw untranslated text, use url.extract instead.
Returns: { url, translated_text, target_lang, truncated }
Example prompts:
\- "Translate https://example.de/artikel into English for me."
\- "Translate this German article into Spanish: [URL]."
\- "Fetch [URL] and give me the French translation."

Input parameters:

- `max_tokens` (number): Input length cap (1 token ≈ 4 chars). Truncates fetched page content before translation. Example: 4000
- `target_lang` (string, required): ISO 639-1 language code for the target language. Example: "es" for Spanish, "fr" for French, "de" for German, "ja" for Japanese, "zh" for Chinese
- `url` (string, required): Public HTTPS URL to fetch and translate. Example: "https://example.de/artikel"

Output parameters:

- `target_lang` (string)
- `translated_text` (string)
- `truncated` (boolean)
- `url` (string)

### `bundle.get` (~279 tokens)

Get Evidence Bundle

Retrieve metadata for an evidence bundle (ev_...) owned by your API key. Free — no credits consumed. Use for quick status/metadata lookups such as checking if a bundle is complete, finding its notarization status, or viewing retention/legal hold info. For deep cryptographic integrity verification (hash + signature + artifact checks), use bundle.verify instead. Also returns a signed action receipt (rcpt_...) binding this lookup to the bundle manifest — list with receipt.list, verify with receipt.verify.
Returns: {
  bundle_id, source_url, mode, status: "pending"|"complete"|"failed",
  manifest_sha256, manifest_signature, signer_address,
  attestation_tx, attestation_at, eas_uid,
  parent_bundle_id, superseded_by,
  legal_hold: boolean, retention_until, created_at,
  receipt: ActionReceipt|null
}
Example prompts:
\- "Show me the metadata for bundle ev_550e8400."
\- "Check the status and notarization info of my evidence bundle."
\- "Get me the details of bundle [ev_id] — is it complete?"

Input parameters:

- `bundle_id` (string, required): Evidence bundle ID (ev_...) returned by extract or bundle.notarize. Example: "ev_550e8400-e29b-41d4-a716-446655440000"

Output parameters:

- `attestation_at`
- `attestation_tx`
- `bundle_id` (string)
- `created_at` (string)
- `eas_uid`
- `legal_hold` (boolean)
- `manifest_sha256`
- `manifest_signature`
- `mode` (string)
- `parent_bundle_id`
- `receipt`
- `retention_until`
- `signer_address`
- `source_url` (string)
- `status` (string)
- `superseded_by`

### `bundle.notarize` (~316 tokens)

Notarize Bundle On-Chain

Notarize an evidence bundle on-chain by writing its manifest SHA-256 to the blockchain (Base/EVM). Creates a permanent, tamper-evident on-chain record of the document fingerprint. If the bundle is already notarized, returns the existing attestation immediately (idempotent). Use when you need an immutable on-chain timestamp proving a document existed at a point in time. For quick integrity checks without on-chain cost, use bundle.verify instead. Also returns a signed action receipt (rcpt_...) binding this notarize call to the bundle manifest — list with receipt.list, verify with receipt.verify.
PREREQUISITE: Bundle status must be "complete". Check status with bundle.get first.
NOTE: Costs gas (ETH). The on-chain record is permanent and cannot be deleted even if the bundle is later purged.
Returns: {
  bundle_id,
  attestation: { tx_hash, network, attested_at, key_id, eas_uid?, schema_uid? },
  receipt: ActionReceipt|null
}
Example prompts:
\- "Notarize bundle ev_550e8400 on-chain so I have a permanent record."
\- "Put the fingerprint of my evidence bundle on the blockchain."
\- "Create an on-chain timestamp for this document bundle."

Input parameters:

- `bundle_id` (string, required): Evidence bundle ID (ev_...) to notarize. Bundle must have status "complete". Example: "ev_550e8400-e29b-41d4-a716-446655440000"

Output parameters:

- `attestation` (object)
- `bundle_id` (string)
- `receipt`

### `receipt.verify` (~245 tokens)

Verify Action Receipt

Independently verify a signed action receipt (rcpt_...) returned by bundle.get, bundle.verify, bundle.notarize, collection.add_document, or listed via receipt.list. Free — no credits consumed. Proves both that the receipt signature is authentic AND that the manifest_sha256 it was bound to still matches the bundle's current manifest — i.e. that the action was not performed against a stale or since-superseded document. Use for third-party audit of an agent's prior actions.
Returns: {
  receipt_id, valid: boolean,
  signature_valid: boolean, manifest_matches_current: boolean,
  bundle_id, agent_id, action, manifest_sha256,
  signer_address, signed_at, tampered: string[]
}
Example prompts:
\- "Verify action receipt rcpt_550e8400 is authentic and still current."
\- "Was this receipt signed against the real document, or a stale copy?"

Input parameters:

- `receipt_id` (string, required): Action receipt ID (rcpt_...) returned in the receipt field of another tool's response. Example: "rcpt_550e8400-e29b-41d4-a716-446655440000"

Output parameters:

- `action` (string)
- `agent_id` (string)
- `bundle_id` (string)
- `manifest_matches_current` (boolean)
- `manifest_sha256` (string)
- `receipt_id` (string)
- `signature_valid` (boolean)
- `signed_at` (string)
- `signer_address` (string)
- `tampered` (array)
- `valid` (boolean)

### `receipt.list` (~259 tokens)

List Action Receipts

List signed action receipts (rcpt_...) for an evidence bundle owned by your API key. Free — no credits consumed. Use after bundle.get, bundle.verify, bundle.notarize, or collection.add_document to audit which agent actions were bound to which manifest hash. Pass a receipt_id from the results to receipt.verify for independent signature + manifest-binding verification.
Returns: {
  bundle_id,
  receipts: [{ receipt_id, bundle_id, agent_id, action, manifest_sha256, signed_at, signature, signer_address, key_id, algorithm }],
  limit, offset
}
Example prompts:
\- "List all signed action receipts for bundle ev_550e8400."
\- "What agent actions have been recorded against this evidence bundle?"
\- "Show me the receipts for [bundle_id] so I can verify one."

Input parameters:

- `bundle_id` (string, required): Evidence bundle ID (ev_...) to list receipts for. Example: "ev_550e8400-e29b-41d4-a716-446655440000"
- `limit` (number): Max receipts to return (default 50, max 200). Example: 50
- `offset` (number): Pagination offset (default 0). Example: 0

Output parameters:

- `bundle_id` (string)
- `limit` (number)
- `offset` (number)
- `receipts` (array)

### `job.status` (~262 tokens)

Get Job Status

Poll the status of an async job (extract, indexing, batch). Free — no credits consumed. Use after collection.add_document or async extract to check when processing completes. Poll this endpoint in a loop until status is "complete" or "failed". Completed jobs include the bundle_id or result_json in the response.
Jobs are created when you POST /v1/extract with a webhook, or when collection.add_document triggers async indexing.
Returns: {
  id, type: "extract"|"extract_batch"|"index_collection",
  status: "queued"|"processing"|"complete"|"failed"|"cancelled",
  progress_pct: number (0–100), progress_message,
  bundle_id (when complete), result_json (when complete),
  error (when failed), created_at, completed_at
}
Example prompts:
\- "Check the status of my indexing job job_550e8400."
\- "Is my async extract job done yet?"
\- "Poll job [job_id] — what is the current progress?"

Input parameters:

- `job_id` (string, required): Job ID (job_...) returned by async extract or collection.add_document. Example: "job_550e8400-e29b-41d4-a716-446655440000"

Output parameters:

- `bundle_id`
- `collection_id`
- `completed_at`
- `created_at` (string)
- `error`
- `id` (string)
- `progress_message`
- `progress_pct` (number)
- `result_json`
- `status` (string)
- `type` (string)

### `collection.list` (~133 tokens)

List Collections

List all document collections owned by your API key. Free — no credits consumed. Use before collection.search or collection.ask when you need the collection ID. Supports pagination with limit and offset.
Returns: { collections: [{ id, name, created_at }] }
Example prompts:
\- "List all my document collections."
\- "Show me the collections I have created."
\- "What collections do I own? List them."

Input parameters:

- `limit` (number): Max collections to return (default 50, max 100). Example: 20
- `offset` (number): Pagination offset (default 0). Example: 0

Output parameters:

- `collections` (array)

### `collection.add_document` (~320 tokens)

Add Document to Collection

Add an evidence bundle to a collection and trigger async vector indexing. Use after collection.create to populate a collection with documents. Once indexed, documents become searchable via collection.search and collection.ask. Indexing is async — poll job.status with the returned job_id until status is "complete". Also returns a signed action receipt (rcpt_...) binding this add call to the bundle manifest — list with receipt.list, verify with receipt.verify.
PREREQUISITE: Bundle must have status "complete" (check with bundle.get). Collection must be owned by your API key.
Returns: { collection_id, bundle_id, job_id (poll for indexing completion), receipt: ActionReceipt|null }
Example prompts:
\- "Add my contract bundle ev_550e8400 to the Q4 Contracts collection."
\- "Put this evidence bundle into my Due Diligence Docs collection for search."
\- "Add document [bundle_id] to collection [col_id] with a title."

Input parameters:

- `bundle_id` (string, required): Evidence bundle ID (ev_...) to add. Bundle must have status "complete". Example: "ev_550e8400-e29b-41d4-a716-446655440000"
- `collection_id` (string, required): Collection ID (col_...) returned by collection.create. Example: "col_550e8400-e29b-41d4-a716-446655440000"
- `title` (string): Optional display title for the document in this collection. Example: "Q4 2025 Financial Report"

Output parameters:

- `bundle_id` (string)
- `collection_id` (string)
- `job_id` (string)
- `receipt`

### `account.quota` (~132 tokens)

Get Quota

Get current credit balance and plan details for your API key. Free — no credits consumed. Check this before running credit-consuming operations (extract, summarize, etc.) to avoid QUOTA_EXCEEDED errors. Returns plan tier, billing period, and usage breakdown.
Returns: {
  plan_id, billing_period (YYYY-MM),
  credits_used, credits_limit, credits_remaining,
  status: "active"|"suspended"
}
Example prompts:
\- "How many credits do I have left this month?"
\- "Check my current quota and plan status."
\- "Am I going to hit my credit limit soon?"

Output parameters:

- `billing_period` (string)
- `credits_limit` (number)
- `credits_remaining` (number)
- `credits_used` (number)
- `plan_id` (string)
- `status` (string)

## Diagnostics

Captured diagnostic sections: TLS, DNSSEC, Authorisation, Transports. The full working is on the page: https://verifymcp.io/servers/com-docimprint-api/api#diagnostics

## Score history

- 2026-08-03: 73
- 2026-08-02: 72
- 2026-08-01: 72
- 2026-07-31: 71
- 2026-07-30: 70
- 2026-07-29: 69
- 2026-07-28: 68
- 2026-07-27: 68
- 2026-07-26: 67

## Links

- Remote endpoint: https://api.docimprint.com/mcp
- Authorisation metadata: https://api.docimprint.com/.well-known/oauth-protected-resource/mcp
- Repository: https://github.com/sawftware-apps/darkroom-gw
- Changelog RSS feed: https://verifymcp.io/servers/com-docimprint-api/api/changelog.xml
- Changelog JSON feed: https://verifymcp.io/servers/com-docimprint-api/api/changelog.json
- HTML version of this page: https://verifymcp.io/servers/com-docimprint-api/api