docraptor
Server Details
Turn HTML or a live URL into polished PDF and Excel files — hosted downloads, async jobs, history.
- Status
- Healthy
- Uptime
- 94.1% over 36 days
- Last Tested
- Transport
- Streamable HTTP · MCP 2025-06-18
- URL
- Repository
- m190/usefulapi-mcp
- GitHub Stars
- 0
TDQS
Scored across 4 tools
Each tool has a clearly distinct purpose: creating documents, checking async status, listing metadata, and retrieving IP addresses. No overlap or ambiguity.
All tools follow a consistent 'docraptor_verb_noun' pattern (e.g., docraptor_create_document, docraptor_list_ip_addresses), making naming predictable.
With 4 tools, the set is well-scoped for the document generation domain, covering creation, status, listing, and utility functions without being excessive or insufficient.
Covers core creation (sync/async), status polling, metadata listing, and IP utilities. Minor gap: no direct retrieval of previously created documents without relying on the download URL from creation.
Available Tools
4 toolsdocraptor_create_documentCreate a document (PDF/XLS/XLSX)ADestructiveInspect
Generate a PDF or Excel document from HTML (document_content) or a URL (document_url). Exactly one of document_content / document_url is required. By default the document is HOSTED and the tool returns a { download_url } you can fetch — ideal for agents (no large binary in the response). Set hosted:false to get the raw document back as base64, or async:true to enqueue a job and poll docraptor_get_document_status. IMPORTANT: real documents consume account credits (billed). Set test:true to generate a FREE, watermarked document while developing. DocRaptor API: POST /docs.
| Name | Required | Description | Default |
|---|---|---|---|
| tag | No | An arbitrary tag string for your own reporting/grouping. | |
| name | No | A name for the document (<=200 chars), shown in the DocRaptor dashboard/listing. | |
| test | No | If true, generate a FREE watermarked test document (does not consume credits). Default false = a real, BILLED document. | |
| type | No | Output format: pdf (default), xls, or xlsx. | |
| async | No | If true, enqueue the job and return a status_id (poll with docraptor_get_document_status). Best for large/slow documents. Default false. | |
| hosted | No | If true (default), DocRaptor hosts the file and returns a download_url. If false, the raw document is returned as base64. | |
| pipeline | No | Rendering pipeline/engine version, e.g. '10'. Omit to use DocRaptor's default. | |
| document_url | No | A URL DocRaptor will fetch and render. Use this OR document_content. | |
| prince_options | No | PDF engine (Prince) options. PDF only. | |
| document_content | No | The HTML/XML source to render. Use this OR document_url. | |
| hosted_expires_at | No | For hosted docs: ISO 8601 datetime when the hosted link expires. | |
| hosted_download_limit | No | For hosted docs: max number of downloads before the link expires. |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Beyond the destructiveHint annotation, the description adds crucial behavioral details: billing consumption, free test mode, hosted vs raw output, async polling, and required input conditions. No contradictions.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is concise at five sentences, covering all key aspects without fluff. It could be slightly improved with bullet points for readability, but it's well-structured and front-loaded with the main action.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the complexity (12 parameters, nested object, no output schema), the description provides essential context: input alternatives, output modes, billing, and test development. It adequately prepares an agent for correct invocation.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
With 100% schema coverage, the description still adds value by explaining mutual exclusivity of document_content/document_url, default values for hosted and test, and the difference between sync and async modes. This goes beyond mere parameter definitions.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states it generates PDF or Excel documents from HTML or URL, with specific verb and resource. It distinguishes itself from sibling tools (status, list, IP) as the only creation tool.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
Provides clear guidance on when to use document_content vs document_url, hosted vs raw, async vs sync, and test vs real. However, it does not explicitly state when not to use this tool or compare to alternative creation tools, which are absent.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
docraptor_get_document_statusGet async document statusARead-onlyInspect
Check the status of an asynchronous document created with docraptor_create_document({async:true}). Returns status (queued | working | completed | failed), and when completed a download_url / download_id / number_of_pages. DocRaptor API: GET /status/{status_id}.
| Name | Required | Description | Default |
|---|---|---|---|
| status_id | Yes | The status_id returned by docraptor_create_document when async:true. |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
The description adds behavioral details beyond the readOnlyHint annotation by listing possible status values (queued, working, completed, failed) and the fields available upon completion (download_url, download_id, number_of_pages). It aligns with the annotation.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Two concise sentences front-loaded with the purpose, followed by return details and API path. Every sentence adds value.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a simple tool with one parameter and readOnly annotation, the description adequately covers usage, return values, and relation to sibling tools. Minor omission of error handling but acceptable.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The input schema already has 100% coverage with a clear description for status_id. The description adds context about where the status_id comes from, but this is a minor addition beyond the schema.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool checks the status of an asynchronous document, specifying the resource and verb. It differentiates from sibling tools like docraptor_create_document and docraptor_list_documents by focusing on status retrieval.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description explicitly indicates the tool should be used after creating an async document with docraptor_create_document({async:true}). While it doesn't mention when not to use it or provide alternatives, the context is clear.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
docraptor_list_documentsList documentsARead-onlyInspect
List metadata for documents created on this account, most recent first (paginated). Note: DocRaptor does not retain the rendered files themselves — this returns metadata such as name, type, test flag, and creation time. DocRaptor API: GET /docs.json.
| Name | Required | Description | Default |
|---|---|---|---|
| page | No | Pagination page number. Default 1. | |
| per_page | No | Documents per page (max 100). Default 100. |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations indicate readOnlyHint=true, and the description reinforces that it lists metadata without destructive actions. It adds context that files are not retained, which goes beyond annotations, but doesn't disclose rate limits or authentication needs.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Two sentences, no redundancy. Key information is front-loaded: purpose, order, pagination, and a critical note about what is returned. Every sentence is valuable.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
No output schema exists, but the description compensates by listing the type of metadata returned (name, type, test flag, creation time). It also mentions pagination and ordering. While not exhaustive on response structure, it is adequate for a simple list tool.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 100% with clear descriptions for page and per_page. The description adds context about pagination and ordering (most recent first), which complements the schema and adds value beyond the parameter descriptions.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states it lists metadata for documents on the account, most recent first, paginated. It distinguishes from sibling tools by specifying it returns metadata, not rendered files, and contrasts with create, status, and IP list tools.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides context about what is returned (metadata, not files) and pagination, helping an agent decide when to use it. However, it doesn't explicitly state when to use this over get_document_status or alternatives.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
docraptor_list_ip_addressesList DocRaptor IP addressesARead-onlyInspect
List the IP addresses DocRaptor uses to fetch remote assets / document_url. Useful for allowlisting DocRaptor on a firewall or asset host. (DocRaptor notes these change over time — prefer HTTP Basic auth over IP allowlisting for securing assets.) DocRaptor API: GET /ips.json.
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare readOnlyHint=true, so the description does not need to repeat that. It adds value by noting IPs change over time and suggesting a security best practice, providing behavioral context beyond the annotation.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Three sentences convey purpose, usage context, and the API endpoint without redundancy. Every sentence adds value, and the description is well-structured.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given no output schema, the description adequately explains the return value (list of IPs) and the tool's utility. It includes a caution about IP changes, making it fairly complete for a simple list tool.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
There are no parameters, so baseline 4 applies. The description does not need to add parameter meaning, and it provides no irrelevant information.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool lists IP addresses used by DocRaptor for fetching remote assets. It distinguishes from sibling tools (create, status, list documents) which perform different operations.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description explains the tool is useful for allowlisting and provides a caution that IPs change over time, recommending Basic auth as an alternative. It does not explicitly compare to sibling tools, but the context is clear.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Tool Schema Changelog
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
4 tool updates
- First observed
docraptor_create_document - First observed
docraptor_get_document_status - First observed
docraptor_list_documents - First observed
docraptor_list_ip_addresses
Related MCP Connectors
Turn HTML or Markdown into a clean, styled PDF and get a download link.
Generate images and PDFs from HTML/CSS, live websites, and reusable templates.
Cloud PDF generation from HTML, CSS and XSL-FO, with PDF/A and PDF/UA support.
Generate HTML to PDF documents in bulk or single — raw replacements or based on conditions, loops
Related MCP Servers
AlicenseAqualityBmaintenanceRenders PDFs from HTML templates or saved templates and spreadsheet data, with batch job support and document retrieval.4643 npm1MIT- AlicenseNot gradedqualityBmaintenanceTurn HTML or a URL into a pixel-accurate PDF in a single tool call.MIT
- AlicenseAqualityCmaintenanceGenerate professional PDFs from Claude, Cursor, and other AI tools. Create invoices, contracts, reports, and certificates from templates or inline HTML markup.730 npm1MIT
- AlicenseBqualityDmaintenanceEnables PDF generation from URLs or HTML strings through the Yakpdf API, allowing users to convert web content into PDF documents.1MIT
Glama MCP Gateway
Add one secure layer between your agents and this server.