The Iteration Layer API includes a built-in Model Context Protocol (MCP) server. MCP lets AI agents like Claude Desktop, Cursor, and Windsurf call the API directly as tools — no custom integration code required.

The MCP server is available via Streamable HTTP transport:

https://api.iterationlayer.com/mcp

The MCP endpoint uses OAuth 2.1 — not API keys. Your MCP client handles the authentication flow automatically. When you first use an Iteration Layer tool, a browser window will open for you to log in and authorize access.

The MCP server exposes one tool per Iteration Layer API:

Convert a document or image to clean markdown. Supports PDF, DOCX, XLSX, images (PNG, JPG, GIF, WebP), HTML, Markdown, CSV, JSON, and plain text.

Parameters:

• file (required) — File input with type, name, and either base64 or url

See Document to Markdown for the full API reference.

Extract structured data from documents using AI. Supports PDF, DOCX, images (PNG, JPG, GIF, WebP), and text files (MD, TXT, CSV, JSON).

Parameters:

• files (required) — Array of file inputs (each with type, name, and either base64 or url)
• schema (required) — Extraction schema with a fields array defining what to extract

See Document Extraction for the full schema reference.

Transform and manipulate images. Supported operations: resize, crop, extend, trim, rotate, flip, flop, blur, sharpen, modulate, tint, grayscale, invertColors, autoContrast, gamma, removeTransparency, threshold, denoise, opacity, convert, upscale, smartCrop, compressToSize, removeBackground.

Parameters:

• file (required) — File input with type, name, and either base64 or url
• operations (required) — Array of transformation operations to apply in order

See Image Transformation for the full operations reference.

Generate images from layer compositions. Layer types: solid-color, gradient, text (with Markdown bold/italic), image, qr-code, barcode, and layout (nested flex-like container with direction, gap, alignment, and padding). Layers are composited by index order with per-layer opacity and rotation.

See Image Generation for the full composition schema.

Generate PDF, DOCX, PPTX, or EPUB documents from structured definitions. Documents are composed of metadata, page settings, styles, and content blocks (paragraph, headline, image, table, grid, list, table-of-contents, page-break, separator, QR code, barcode).

See Document Generation for the full document schema.

Generate XLSX, CSV, or Markdown spreadsheets from structured tabular data. Define columns and positional rows of cells with optional formatting (currency, percentage, number, decimal, date, datetime, time, custom), cell styles, merged cell spans, and Excel formulas. Supports multiple sheets, ISO 4217 currency codes, and custom fonts.

See Sheet Generation for the full schema reference.

Add to your claude_desktop_config.json:

{
  "mcpServers": {
    "iterationlayer": {
      "type": "http",
      "url": "https://api.iterationlayer.com/mcp"
    }
  }
}

Add to your .cursor/mcp.json:

{
  "mcpServers": {
    "iterationlayer": {
      "type": "http",
      "url": "https://api.iterationlayer.com/mcp"
    }
  }
}

Add to your Windsurf MCP configuration:

{
  "mcpServers": {
    "iterationlayer": {
      "type": "http",
      "url": "https://api.iterationlayer.com/mcp"
    }
  }
}

Every tool follows the same file input convention:

{
  "type": "url",
  "name": "document.pdf",
  "url": "https://example.com/document.pdf"
}

Or for inline content:

{
  "type": "base64",
  "name": "document.pdf",
  "base64": "JVBERi0xLjQK..."
}

Every tool that produces binary output (images, documents, spreadsheets) returns the same structure:

{
  "buffer": "base64-encoded-content",
  "mime_type": "application/pdf"
}

This consistency matters for composability. The output format of generate_image matches the input format of generate_document's image blocks. The agent does not need to convert between formats or understand format-specific encoding.

All tools share a single endpoint, the same authentication, the same credit pool, and compatible I/O formats. This makes multi-step agent workflows natural.

Extract structured data from a document, then generate a report from the extracted data.

Flow: extract_document → application logic → generate_document

The extraction returns structured JSON. The document generation accepts structured JSON. No format conversion, no intermediate files. The agent reads the extraction result, builds a document definition from it, and generates the output.

When the document needs to be understood as a whole, convert it to markdown first, then extract specific data, then generate output.

Flow: convert_document_to_markdown → extract_document → generate_document or generate_sheet

The markdown conversion gives the agent the full document text for context. The extraction pulls specific structured fields. This pattern works well when the agent needs to both summarize content (from the markdown) and pull precise values (from the extraction).

Combine document data with processed images to create visual output.

Flow: extract_document → transform_image → generate_image

The extraction provides the data (product name, price, description). The image transformation prepares visual assets (resize, background removal, format conversion). The image generation composites everything into a final visual.

Process multiple documents and aggregate results into a single spreadsheet.

Flow: extract_document (multiple calls) → generate_sheet

Each extraction returns structured data for one document. The agent collects the results and generates a spreadsheet with one row per document. Confidence scores can be included as a column for filtering.

The agent extracts vendor name, invoice number, line items, totals, and payment terms from supplier invoices. It evaluates confidence scores, generates a PDF summary for approved invoices and a review report for flagged ones, then exports the batch to an XLSX spreadsheet for accounting.

Tools used: extract_document → confidence routing → generate_document (summary or review) → generate_sheet (batch export)

The agent converts a long-form PDF whitepaper to markdown, extracts the title, author, key takeaways, and statistics, generates a social card image with the title and a branded gradient, and generates a one-page PDF executive summary.

Tools used: convert_document_to_markdown → extract_document → generate_image (social card) → generate_document (summary)

The agent extracts product names, descriptions, prices, and SKUs from a supplier catalog PDF. It takes each product photo, removes the background, resizes to marketplace-required dimensions, and converts to WebP. It then generates product card images with standardized layouts.

Tools used: extract_document → transform_image (per product) → generate_image (per product)

The agent converts a contract to markdown for full-text review, extracts structured data (parties, effective date, termination clauses, payment terms, governing law), and generates a review checklist as a DOCX with the extracted terms pre-filled and blank fields for reviewer notes.

Tools used: convert_document_to_markdown → extract_document → generate_document

MCP is ideal for interactive agent workflows — Claude Code sessions, Cursor conversations, ad-hoc processing tasks. For production pipelines, the same tools are available through the TypeScript, Python, and Go SDKs.

Every method also has an async variant that accepts a webhook_url for non-blocking processing:

The parameters, request shapes, and response shapes are identical between MCP and SDK. A workflow prototyped in Claude Code via MCP translates directly to production code via the SDK.

Find the Iteration Layer MCP server on these directories:

• Official MCP Registry — com.iterationlayer/mcp
• Glama.ai
• Smithery.ai

MCP tool calls consume credits the same way as direct API calls. See Credits & Pricing for details.