API Platform

Get started in 3 steps

Register the MCP server and install Skills. Then just tell your AI agent to create a presentation — PowerPoint is generated automatically.

Get started

terminal▾

1# 1. Register MCP servers
2# Claude Code / Codex / Grok Build users: run the matching one line
3npx --yes --package html2pptx-local-mcp@latest html2pptx-install-mcp claude
4npx --yes --package html2pptx-local-mcp@latest html2pptx-install-mcp codex
5# Grok Build
6npx --yes --package html2pptx-local-mcp@latest html2pptx-install-mcp grok
7
8# 2. Install Skills (run only the line for your tool)
9npx skills add https://html2pptx.app -a claude-code  # Claude Code
10npx skills add https://html2pptx.app -a codex        # Codex
11npx skills add https://html2pptx.app -a cursor       # Cursor
12npx skills add https://html2pptx.app -a windsurf     # Windsurf
13# Grok Build
14npx --yes --package html2pptx-local-mcp@latest html2pptx-install-skills grok
15
16# 3. Use natural language
17# "Create a presentation from these meeting notes"
18# -> Agent generates HTML -> converts to PPTX

Service Overview

What is html2pptx.app

html2pptx.app converts slide-oriented HTML/CSS into PowerPoint. Supported text and simple shapes remain editable; SVGs, icons, and some complex structures are rasterized. Flexbox, Grid, gradients, and shadows are supported within the published HTML contract. Review each export because browser and PowerPoint rendering can differ.

Architecture

html2pptx.app uses a staged pipeline that separates request handling, durable job state, rendering, and delivery:

Step 01

Client

Your application, agent, or script sends HTML/CSS via REST API. Any language or platform that can make HTTP requests works.

Step 02

API Gateway

Handles authentication (Bearer / X-API-Key), rate limiting per plan tier, request validation, and the initial job creation request.

Step 03

Durable Queue

Job metadata is stored in Convex, large request payloads are stored in object storage, and Cloud Tasks can dispatch processing without losing jobs on worker restart.

Step 04

Private Worker

The private renderer loads the saved job, maps supported HTML/CSS to PowerPoint objects or images, and updates the durable job state as it progresses.

Step

PPTX Output

The generated PowerPoint file is uploaded to cloud storage and a time-limited signed URL is returned for download. Retention follows the deployment policy, so check the job status for the current result and save it promptly.

Three Integration Channels

REST API

Standard HTTP endpoints for creating HTML-to-PPTX export jobs and polling status. Best for backend integrations, internal tools, and SaaS embedding. Works with any language -- curl, JavaScript, Python, Go, Ruby, and more. Creator-owned template draft creation is not a REST API surface.

Skills

Register the html2pptx skill for agent tools like Claude Code and Codex. The agent can diagnose, rewrite, export slide-safe HTML, open local editing, and create validated HTML template drafts through the built-in remote MCP workflow. Ideal for AI-powered workflows where the agent manages the full pipeline.

MCP (Model Context Protocol)

Expose the backend to AI agents via the MCP protocol. Use the remote HTTP endpoint at /mcp for export, docs, catalog, and the supported public creator-owned template draft workflow; use local stdio MCP only for opening local HTML in edit-slide. The documented draft workflow validates and saves HTML through authenticated remote MCP.

How html2pptx.app Compares

Feature	html2pptx.app	Typical alternatives
Conversion method	Supported elements become PPTX objects; selected content is rasterized	Varies: object conversion or slide images
Text editability	Editable for supported text elements	Varies by conversion method
CSS support	Published subset including Flexbox, Grid, gradients, shadows, and transforms	Varies by provider
SVG handling	Rasterized to PNG	Varies by provider
File size	Depends on embedded and rasterized imagery	Depends on output model and imagery
Font handling	System-font mapping; public REST does not fetch external web fonts	Varies by provider

Supported CSS Features

Category	Supported properties
Layout	display: flex, display: grid, position: absolute/relative, gap, align-items, justify-content
Box Model	padding, margin, width, height, box-sizing, overflow: hidden
Background	background-color, linear-gradient(), radial-gradient(), background-image (URL/base64)
Border	border, border-radius (including per-corner), border-color, border-width
Shadow	box-shadow (single and multiple), text-shadow
Typography	font-family, font-size, font-weight, color, text-align, line-height, letter-spacing
Transform	transform: rotate(), scale(), translate(), skew()
Visual	opacity, visibility, z-index, object-fit

Use Cases

•Automated report generation from live data sources
•Agent-powered presentation creation from text prompts
•Internal tool integration for recurring slide decks
•SaaS export feature embedding (dashboard-to-PPTX)
•Brand-compliant template population
•Meeting notes to presentation conversion via AI agents

Supported Features

Inline SVGs are rasterized to PNG and are not editable as vectors in PowerPoint
System-font mapping with explicit output review for substitutions and line wrapping
Flexbox and CSS Grid support within the published subset; review the resulting layout
Gradients, shadows, and border-radius support within the HTML contract; browser parity is not guaranteed
Base64 data URI and absolute-URL image support
Explicit slide canvases with custom width/height/layout support. 1600x900px (13.333in x 7.5in) remains the default example
Multi-slide support (each .slide element becomes one PPTX slide)
Japanese font support (Noto Sans JP, Yu Gothic, Meiryo)
Hosted Studio and hosted web export for manual use in the browser

Quick Start

Your first authenticated export in 4 steps

The REST API is asynchronous: create a job, poll its status, then use downloadUrl when it completes.

Sign Up

Create an account at html2pptx.app. Free Preview includes one API key and up to 10 exports per month for limited evaluation. Founder Beta expands the quota for continued and commercial use.

Get API Key

Navigate to the Dashboard and click "Create API Key". Copy and store it securely -- it will only be shown once. Your key starts with sk_live_ and should be treated as a secret.

Send First Request

POST your HTML slide content to /api/export/jobs with your API key in the Authorization header. The API returns a jobId that you can use to track the export.

Download PPTX

Poll GET /api/export/jobs/{jobId} until status is "completed". The response normally includes a downloadUrl for the PPTX file; fileBase64 may appear only as a worker fallback when a URL cannot be produced.

Code Examples

1curl -X POST https://html2pptx.app/api/export/jobs \
2  -H "Authorization: Bearer sk_live_xxxx" \
3  -H "Content-Type: application/json" \
4  -H "Idempotency-Key: my-unique-request-id-123" \
5  -d '{
6    "fileName": "quarterly-review.pptx",
7    "html": "<section class=\"slide\" style=\"width: 1600px;height: 900px;padding: 64px\"><h1>Hello</h1><p>Generated via API</p></section>",
8    "css": ".slide { font-family: Arial, sans-serif; background: #fff; }",
9    "autoEmbedFonts": false,
10    "metadata": {
11      "channel": "api",
12      "source": "docs-quickstart"
13    }
14  }'
15
16# Response (200 OK):
17# {
18#   "jobId": "5d934729-a0db-4aa9-bc65-e7a3e7e52b32",
19#   "status": "queued",
20#   "createdAt": "2026-04-02T10:30:00Z",
21#   "fileName": "quarterly-review.pptx",
22#   "slideCount": 1
23# }
24# Response headers include: x-request-id: req_abc123...
25
26# Poll for completion:
27curl -s https://html2pptx.app/api/export/jobs/5d934729-a0db-4aa9-bc65-e7a3e7e52b32 \
28  -H "Authorization: Bearer sk_live_xxxx"
29
30# Response (200 OK, when completed):
31# {
32#   "jobId": "5d934729-a0db-4aa9-bc65-e7a3e7e52b32",
33#   "status": "completed",
34#   "createdAt": "2026-04-02T10:30:00Z",
35#   "completedAt": "2026-04-02T10:30:12Z",
36#   "fileName": "quarterly-review.pptx",
37#   "slideCount": 1,
38#   "mimeType": "application/vnd.openxmlformats-officedocument.presentationml.presentation",
39#   "downloadUrl": "https://storage.example.com/quarterly-review.pptx?token=..."
40# }

API Reference

Connection Details

Base URL: Base URL: https://html2pptx.app

Content-Type: Export job creation, status, and plan endpoints use application/json. PPTX import accepts either multipart/form-data with a file or application/json with pptxBase64; see the OpenAPI document for the exact contract. The create endpoint accepts top-level html or a same-key templateId, plus data, css, fileName, and optional size controls; there is no nested payload wrapper.

Authentication

Commercial export endpoints require authentication. Create and revoke API keys from the Dashboard, send a key in one of the following headers, and store it as a secret.

AuthorizationBearer sk_live_xxxxRecommended -- standard Bearer token format used by most HTTP clients and libraries

X-API-Keysk_live_xxxxAlternative header for environments where Authorization is reserved (e.g., API gateways, proxies)

Job Lifecycle Notes

POST /api/export/jobs returns immediately with a queued job descriptor. It does not block until the PPTX is finished.
Use the public status route at GET /api/export/jobs/{jobId}. Do not rely on any upstream worker URL that may appear in internal payloads.
The completed REST response normally includes downloadUrl. fileBase64 may appear only as a worker fallback when a URL cannot be produced; public REST callers cannot select a response format.
Job ownership is bound to the API key or authenticated MCP principal that created the job. A different key cannot read the same jobId.
Slide count is derived server-side from sanitized .slide roots. Client-provided counts are ignored for enforcement.

Rate Limiting

Commercial export responses expose rate and quota headers after a plan is resolved. Available headers vary by plan and response path. REST calls are limited per API key; remote MCP calls are limited per authenticated principal.

Header	Description
`x-request-id`	Request identifier returned by export endpoints for tracing. Preserve it when debugging or contacting support.
`X-Plan-Id`	The effective plan ID applied to the request.
`X-RateLimit-Limit`	Maximum requests allowed in the current one-minute window.
`X-RateLimit-Remaining`	Requests remaining in the current window.
`Retry-After`	Seconds to wait before retrying after a 429 response.
`X-Daily-Limit`	Returned on plans with a daily export cap.
`X-Daily-Remaining`	Remaining jobs in the current UTC day.
`X-Monthly-Used`	Exports accepted in the current UTC month.
`X-Fair-Use-State`	Monthly fair-use status such as normal, review, or upgrade_recommended.

POST/api/v1/import/pptx

Import PPTX to HTML

Converts an existing .pptx into editable HTML slides (the reverse of export). Resolves theme colors (including clrMap/clrMapOvr inversion on dark slides), master text styles, and font families. Synchronous — returns the HTML in a single response. Also available at POST /api/import/pptx.

Request Body

filefile

multipart/form-data: the .pptx file (max 25 MB). Use this OR pptxBase64.

pptxBase64string

application/json: base64-encoded .pptx contents (data URLs accepted). Recommended for JSON-RPC / MCP clients.

fileNamestring

Optional original file name used for labeling.

Default: presentation.pptx

Error Codes

400Missing/invalid file, invalid base64, or invalid OOXML.

401Missing API key. Set the Authorization: Bearer or X-API-Key header.

403API key is not mapped to a plan with API access.

413PPTX exceeds the 25 MB size limit.

Response (200 OK)▾

1{
2  "fileName": "deck.pptx",
3  "plan": "api_starter",
4  "slideCount": 13,
5  "slides": [{ "index": 1, "html": "<section class=\"slide\">...</section>" }],
6  "html": "<!doctype html>...",
7  "css": "...",
8  "warnings": []
9}

POST/api/export/jobs

Create Export Job

Creates a new PPTX export job from inline HTML/CSS or a reusable templateId owned by the same API key. The response is a queued job descriptor; use GET /api/export/jobs/{jobId} to retrieve terminal results.

Request Body

fileNamestring

Output filename for the generated PPTX. Must end with .pptx extension.

Default: export.pptx

htmlstring

Slide-oriented HTML containing one or more .slide elements. Required unless templateId resolves to a reusable template owned by this API key.

cssstring

Optional CSS applied globally to the submitted HTML.

Default: ""

templateIdstring

Reusable export template ID beginning with tpl_ and registered to the same API key. May be used instead of html.

dataobject

Template variables merged into html/css or the reusable template before sanitization.

Default: {}

autoEmbedFontsboolean

Compatibility input forwarded to the renderer. Public REST removes @font-face rules and blocks external font downloads, so this does not fetch Google Fonts or custom web fonts.

Default: false

slideCountinteger

Deprecated input retained for compatibility. The public gateway ignores it and recalculates the effective count from sanitized .slide elements.

widthnumber

Optional PPTX slide width in inches. Use with height for custom presentation sizes.

heightnumber

Optional PPTX slide height in inches. Use with width for custom presentation sizes.

layoutstring

Optional PPTX layout preset or custom layout name. Common presets: LAYOUT_16x9, LAYOUT_16x10, LAYOUT_4x3, LAYOUT_WIDE.

aspectRatiostring

Optional ratio using 16:9, 16:10, or 4:3 (the separators :, x, and × are accepted). Unsupported values are ignored.

metadataobject

Opaque metadata forwarded to the worker. Useful for request tracing on your side.

Default: {}

callbackUrlstring

An HTTPS URL to receive a completion or failure hint. The payload contains jobId/status plus fileName on success or message on failure; it is not the full result. No customer-verifiable webhook signing contract is currently exposed, so treat the callback as unauthenticated and fetch the result from the authenticated status endpoint. Only https:// URLs are accepted.

Error Codes

400Invalid request body -- missing required fields or malformed JSON.

401Missing or invalid API key. Ensure the Authorization or X-API-Key header is set with a valid sk_live_ key.

403API key does not have permission for this operation. Check plan limits or key scope.

404The supplied reusable templateId was not found for this API key.

413Request entity too large. The total request body exceeds your plan limit or the worker hard cap.

422The sanitized HTML resolves to more slides than your plan allows.

429Rate limit exceeded, daily limit exceeded, monthly fair-use review triggered, or concurrent job limit exceeded. Check Retry-After and usage headers.

502Bad gateway -- the worker backend is temporarily unavailable. Retry after a short delay.

503Service unavailable -- the system is under maintenance or experiencing high load. Retry with exponential backoff.

Response (200 OK)▾

1{
2  "jobId": "5d934729-a0db-4aa9-bc65-e7a3e7e52b32",
3  "status": "queued",
4  "createdAt": "2026-04-02T10: 30: 00Z",
5  "fileName": "quarterly-review.pptx",
6  "slideCount": 1
7}

GET/api/export/jobs/{jobId}

Check Job Status

Retrieves the current status of an export job. Poll until status is "completed" or "failed". A completed response normally includes downloadUrl; fileBase64 may appear only as a worker fallback.

Path Parameters

jobIdstringRequired

The job ID returned from the POST /api/export/jobs endpoint.

Status Values

queued

Job is waiting in the processing queue.

processing

Worker is actively converting HTML to PowerPoint.

completed

Conversion finished successfully. downloadUrl is normally available; fileBase64 may be present as a fallback.

failed

Conversion failed. The message field contains a human-readable description.

Error Codes

401Missing or invalid API key.

404Job not found -- either the jobId is invalid or the job belongs to a different API key.

429Status polling rate limit exceeded.

Response (200 OK)▾

1{
2  "jobId": "5d934729-a0db-4aa9-bc65-e7a3e7e52b32",
3  "status": "completed",
4  "createdAt": "2026-04-02T10: 30: 00Z",
5  "completedAt": "2026-04-02T10: 30: 12Z",
6  "fileName": "quarterly-review.pptx",
7  "slideCount": 3,
8  "mimeType": "application/vnd.openxmlformats-officedocument.presentationml.presentation",
9  "downloadUrl": "https://storage.example.com/quarterly-review.pptx?token=..."
10}

GET/api/export/plans

List Plans

Returns the public plan catalog plus the recommended default plan. No authentication required.

Response (200 OK)▾

1{
2  "recommendedPlanId": "founding_beta",
3  "plans": [
4    {
5      "id": "free_web",
6      "name": "Free Preview",
7      "includes": { "api": true, "skills": true, "mcp": true },
8      "limits": {
9        "requestsPerMinute": 3,
10        "dailyRequestLimit": 10,
11        "monthlyRequestLimit": 10,
12        "monthlyReviewThreshold": 0,
13        "monthlyUpgradePromptThreshold": 0,
14        "maxSlidesPerJob": 20,
15        "concurrentJobs": 1,
16        "apiKeys": 1,
17        "maxPayloadBytes": 1048576
18      }
19    }
20  ],
21  "note": "Free Preview is generous for personal use. Paid tiers unlock commercial operation, team sharing, automation throughput, and support."
22}

GET/api/openapi.json

OpenAPI Specification

Returns the OpenAPI 3.x specification for the html2pptx.app API. Useful for generating client SDKs, importing into Postman, or browsing the API schema.

Response (200 OK)▾

1// Returns the full OpenAPI 3.x JSON document

HTML Contract

The HTML you send must follow these rules for reliable conversion.

Each slide must have the class .slide -- this is the boundary marker for slide separation
Each .slide must have explicit dimensions. 1600px x 900px (16:9 ratio at 13.333in x 7.5in) is the default example, and API/MCP callers can also set width, height, or layout for portrait/custom output
Supported CSS: flexbox, grid, linear-gradient, radial-gradient, box-shadow, text-shadow, border-radius, transform (rotate, scale, translate, skew), opacity
Fonts: use fonts installed in the render and target PowerPoint environments. Public REST removes @font-face rules and blocks external font downloads; inspect substitutions and line wrapping
Images: both base64 data URIs and absolute URLs are supported. Relative paths will fail -- always use absolute URLs
SVGs: inline SVG elements are supported and are converted to high-quality PNG images
Avoid: script tags, iframes, script-dependent canvas content, external video URLs, anchor tags, form elements, SVG external references, CSS animations, @keyframes, and runtime-dependent state
Nesting: deeply nested elements (> 10 levels) may impact output quality. Keep your HTML structure flat where possible
Text wrapping: text boxes default to no-wrap to prevent unexpected line breaks in PPTX. If you need text to wrap within a container (e.g. long paragraphs), add white-space: normal to that element

Error Response Format

Commercial export errors use RFC 9457 Problem Details with additional legacy fields for backwards compatibility. Some legacy and creator endpoints return a smaller error object:

1{
2  "type": "https://html2pptx.app/errors/slides-limit-exceeded",
3  "status": 422,
4  "title": "Slides limit exceeded",
5  "detail": "Plan Starter supports up to 200 slides per job. You submitted 260 slides.",
6  "instance": "/api/export/jobs",
7  "error": "slides_limit_exceeded",
8  "message": "Plan Starter supports up to 200 slides per job.",
9  "slideCount": 260
10}

Supported HTML Elements

Supported elements are converted as noted below. Editability varies by element; rows mapped to images are rasterized in PowerPoint.

HTML Element	PPTX Output	Notes
`div, section, article`	Shape with fill	Background colors, gradients, borders, and rounded corners are preserved.
`p, h1-h6, span, b, em, strong, i, small`	Text box	Text becomes an editable PowerPoint text box. Supported font, alignment, and line-height properties are mapped; verify wrapping and spacing after export. Inline elements (span, b, em, etc.) become styled text runs within the same text box.
`img`	Image	Supports absolute URLs and base64 data URIs. CSS object-fit (contain, cover, fill, scale-down) and object-position are respected. Rounded corners are applied via clipping.
`table, tr, td, th`	Native PPTX table	Cell-level text styling, background fill, borders (solid/dashed/dotted), padding, text alignment, and colspan/rowspan are supported within the table contract; review complex tables after export.
`ul, ol, li`	Bulleted / Numbered list	Simple lists become editable bullet or numbered lists. Complex lists (with images or flex/grid inside) are converted as images.
`svg`	Image (PNG)	Inline SVGs are rasterized to PNG and are not editable as vectors.
`video`	Playable media or poster image	A base64 data:video source can be embedded as PowerPoint media. External video URLs are not fetched. A base64 data:image poster can be used as the cover or fallback.
`canvas`	Not supported by hosted REST/MCP	Canvas bitmap state is not serialized into an HTML string. Render it to PNG first and submit an <img> with an allowed data:image source.
`Icon elements (FontAwesome, Material Icons, etc.)`	Image	Detected icon fonts are converted to images and are not editable as text or vectors.

Unsupported or Removed Elements

The following elements are removed during sanitization or unsupported by the renderer. Do not rely on them in slide HTML:

script, iframe, object, embed

Security: active content removed

external video URLs, script-dependent canvas

External video is not fetched and submitted scripts are removed

link, meta, base

Security: external references removed

form

Interactive elements not supported in PPTX

style

Use inline styles or the css parameter instead

a

Anchor tags stripped for security

foreignobject, image (SVG), feimage, use

SVG external references removed

animate, animateMotion, animateTransform, set, discard, mpath

SVG animations not supported

Skills Integration

What are Skills

Skills are packaged capabilities that extend AI coding agents with domain-specific knowledge and workflows. The html2pptx.app skill teaches your agent how to author slide-safe HTML, validate it against the PPTX conversion contract, optionally open the local visual editor through local stdio MCP, export through remote MCP, and create validated HTML template drafts through remote MCP. The dashboard can share reviewed drafts as unlisted pages; new public-gallery publishing is currently disabled. The resulting PPTX remains an export candidate: validate the markup and visually review the file before distribution.

How it works

The skill bundles four core capabilities: (1) HTML authoring knowledge -- the rules for writing HTML/CSS within the published PowerPoint conversion contract, (2) remote MCP-based export automation -- creating jobs, polling status, and retrieving results through the hosted html2pptx.app MCP server, (3) local visual editing -- using the local stdio MCP open/stop editor tools and a localhost bridge when the user wants to inspect or tweak HTML before export, and (4) template draft creation -- requiring HTML drafts to go through the remote MCP validate/save loop. The agent should ask before adding a local MCP server because that changes the user’s MCP configuration.

Works with 18+ AI agents including Claude Code, Codex, Cursor, VS Code (GitHub Copilot), Grok Build, Antigravity, and more. Use the skills CLI command for Claude Code, Codex, and Cursor. For Grok Build, use the Grok-specific skills installer shown below.

Workflow

1Agent receives a user request (e.g., "Create a deck from these meeting notes")
2Agent reads the skill definition to understand the html2pptx.app HTML contract
3Agent generates slide-safe HTML with .slide class elements and explicit dimensions. 1600x900 is the default example
4Agent validates the markup against the conversion contract
5If visual review is needed, the agent opens the local edit-slide editor through the CLI or local stdio MCP, then re-reads the edited HTML from disk
6Agent connects to remote MCP and calls html2pptx_create_export_job
7Agent polls with html2pptx_wait_for_export_job until completed
8If the user wants to create an HTML template draft, the agent uses the html2pptx skill and remote MCP: infer title/tags from the HTML, run AI security preflight, validate, fix errors, save a draft, then return draftUrl for dashboard review
9Agent returns the completed job summary to the user

Local Visual Editor

The edit-slide skill lets an agent open a local HTML slide deck in a PowerPoint-style visual editor served from an available loopback origin such as http://localhost:<port>. Hosted edit-slide is not allowed for local file editing. The local dev script chooses a free port and registers it in .html2pptx/edit-slide/editor-server.json inside the current project. The deck file stays on the user machine and is read/written through a localhost bridge started by the CLI or by the local stdio MCP tool. If the local MCP server is not already configured, the agent should explain that it will change MCP settings and ask the user before adding it.

local editor▾

1# From the project that contains your slide HTML
2node scripts/dev-studio.mjs
3npx --yes https://html2pptx.app/downloads/html2pptx-cli-0.4.0.tgz edit ./html2pptx/slides.html
4
5# If html2pptx-cli@0.4.0+ is available from npm
6npx --yes html2pptx-cli edit ./html2pptx/slides.html
7
8# If the CLI is installed globally
9html2pptx edit ./html2pptx/slides.html
10
11# Print the URL instead of opening a browser
12html2pptx edit ./html2pptx/slides.html --no-open

How the local editor flow works

1. Choose remote or local MCP

Use remote MCP for normal PPTX export and catalog/docs tools. Use local stdio MCP only when the agent must open or edit a local `.html` / `.htm` file through edit-slide. If local MCP is missing, ask the user before installing it.

2. Start bridge

`html2pptx edit <file>` or `html2pptx_open_local_slide_editor` starts a tiny HTTP server on `127.0.0.1`. Unless a port is specified, the OS assigns a free port. Access is scoped to the current working directory.

3. Open editor

The command opens `http://localhost:<editor-port>/edit-slide?file=...&bridge=http://127.0.0.1:<bridge-port>#bridgeToken=...`. The one-time token is kept in the URL fragment and the editor removes it from the address bar after startup.

4. Load local file

The browser editor presents the token and fetches the selected `.html` or `.htm` file from the localhost bridge. No marketplace draft or public page is created.

5. Edit visually

Users can click slide elements and adjust text, typography, color, size, padding, margin, radius, border, opacity, and other properties from the right panel.

6. Save to disk

Edits are serialized back into the same HTML file through the bridge with an optimistic file hash. No version history, backups, or audit log are created.

7. Continue with the agent

After manual edits, the agent should re-read the HTML file from disk. If the user wants PowerPoint output, handle it as a separate agent task with the html2pptx skills.

Privacy and file access model

The bridge binds to `127.0.0.1` only. Other users cannot open the local bridge from the network.
Each bridge run generates a per-session token that the editor must present for local reads and writes. The visible URL is redacted after startup.
The slide preview uses no-referrer handling so external images or fonts do not receive the tokenized editor URL.
Only `.html` and `.htm` files under the current working directory are accepted.
Sensitive project directories such as `app/`, `components/`, `lib/`, `.git/`, `.next/`, and `node_modules/` are blocked.
Visual editing does not publish or upload the deck. The Export PPTX button only displays a prompt telling the user to ask Claude Code or another agent to use the html2pptx skills for PowerPoint output.
Adding the local stdio MCP server is a configuration change in the user’s agent environment. Skills and agents should not add it silently; ask first, then proceed only after confirmation.
Editor state is project-local under `.html2pptx/edit-slide/`. No version history, backups, or audit log are created.

Common issues

The command is not found

Start `node scripts/dev-studio.mjs`, then use `npx --yes https://html2pptx.app/downloads/html2pptx-cli-0.4.0.tgz edit ./path/to/slides.html`, or install `html2pptx-cli@0.4.0+` globally.

`npx` is not available

Use the already-configured local stdio MCP tool `html2pptx_open_local_slide_editor`, or ask before adding local MCP. If local MCP is unavailable, install/expose npm or a global `html2pptx` CLI first.

The editor opens but the deck does not load

Confirm the path is relative to the directory where the command was run and the file extension is `.html` or `.htm`.

Changes do not save

Keep the terminal running. Closing the `html2pptx edit` process stops the localhost bridge.

The agent wants to add local MCP

Confirm with the user first. Local MCP is optional and only needed for MCP-driven local edit-slide sessions; remote MCP can still export PPTX without local file access.

Another tab is read-only

The editor uses a local tab lock to avoid two tabs writing to the same file. Use the active tab or click the transfer edit control.

Setup

Pick the agent you actually use and run the matching command. The skills CLI handles Claude Code, Codex, Cursor, VS Code (GitHub Copilot), and Antigravity; Grok Build uses its own installer. The tab list mirrors the MCP setup tabs below so the same agent appears in the same place in both sections.

Claude Code

Install the html2pptx skill

terminal

1npx skills add https://html2pptx.app -a claude-code

Preview without installing

List the skills the CLI is about to add before committing to them.

terminal

1npx skills add https://html2pptx.app --list

Tip: Prefer the per-agent flag over `--yes`. `--yes` installs into every detected agent directory at once.

Available Skills

html-to-pptx-slide-authoring

スライド用HTML/CSSの作成・診断・修正。HTMLがPPTXに正しく変換されるかを事前チェックし、問題があれば自動で書き換え。

HTML診断（safe / needs-rewrite / out-of-scope）
マークアップ自動書き換え
スライドHTML新規生成
入力バリデーション

pptx-studio-export-automation

APIジョブの作成・ステータス管理・エラーハンドリング。REST API / MCP の使い分け判断も含む。

エクスポートジョブ作成
ポーリング＆完了待機
エラー分析＆リトライ
プラン制限の事前チェック

edit-slide

ローカルHTMLスライドをlocalhost上のvisual editorで開き、localhost bridge 経由で同じファイルに保存。

html2pptx edit <file>
PowerPoint風UIで視覚編集
ローカルHTMLへの自動保存
変更検知と競合防止

Skill Capabilities

Diagnose HTML

Classify markup as safe, needs-rewrite, or out-of-scope before attempting export. Catches issues like missing .slide elements, unsupported CSS, or dynamic content.

Rewrite Markup

Transform web-shaped HTML (responsive layouts, percentage-based sizing, scroll containers) into fixed-size .slide structures suitable for PPTX conversion.

Generate Slides

Create new slide-safe HTML from scratch given a text prompt, topic outline, or data payload. Applies best practices for visual hierarchy and readability.

Validate Output

Run the generated HTML through a pre-flight check against the html2pptx.app HTML contract before making the API call, preventing wasted export quota on invalid input.

Create Template Drafts

For creator-owned HTML drafts, the supported public workflow is AI security preflight, remote MCP validation, and authenticated draft creation. CLI, local MCP, and generic REST are not supported draft-creation contracts; legacy or hidden web surfaces are outside this public workflow. Reviewed drafts can be shared as unlisted pages; new public-gallery publishing is disabled.

MCP Integration

Install

Claude Code runs this one line (remote export + local edit-slide)

npx --yes --package html2pptx-local-mcp@latest html2pptx-install-mcp claude

Codex runs this one line (remote export + local edit-slide)

npx --yes --package html2pptx-local-mcp@latest html2pptx-install-mcp codex

Grok Build runs this one line (remote export + local edit-slide)

npx --yes --package html2pptx-local-mcp@latest html2pptx-install-mcp grok

What is MCP

MCP (Model Context Protocol) is an open protocol that exposes backend capabilities to AI agents through a standardized tool interface. html2pptx.app supports two MCP surfaces: the remote HTTP MCP endpoint at /mcp for export, import, usage, docs, templates, catalog, and creator-owned HTML template drafts; and the local stdio MCP server, which exposes only html2pptx_open_local_slide_editor and html2pptx_stop_local_slide_editor for local edit-slide sessions through a localhost bridge. Use remote MCP for export jobs, PPTX import, job polling, or HTML template drafts. Use local stdio MCP only when the agent must open, preview, edit, or stop editing a local HTML file on the user machine.

Installation & Setup

Claude Code, Codex, and Grok Build users can run one command to register both remote export tools and local edit-slide. Remote MCP follows the hosted service; local MCP uses html2pptx-local-mcp@latest so future starts pick up the newest published package.

Claude Code

Claude Code users: run this one line

This registers remote export as `html2pptx`, then writes local edit-slide as `html2pptx-local` directly into Claude Code user config.

terminal

1npx --yes --package html2pptx-local-mcp@latest html2pptx-install-mcp claude

Manual remote setup

If you only need hosted export tools, add the remote MCP server directly.

terminal

1claude mcp add --scope user --transport http html2pptx https://html2pptx.app/mcp

Compatible local edit-slide setup

If Claude Code stdio registration is unreliable, use the installer because it writes the local server entry directly.

terminal

1npx --yes --package html2pptx-local-mcp@latest html2pptx-install-mcp claude

Tip: The installer registers the remote MCP with user scope and writes the local stdio MCP directly to Claude Code user config for better compatibility.

Authentication

The MCP server supports two authentication methods. Choose the one that best fits your use case. API keys are fine for export, docs, usage, and catalog tools, but html2pptx_publish_template requires a WorkOS-bound user token because template drafts need a creator identity.

API Key (Recommended)

Use an API key from the dashboard. API keys do not expire (unless you set an expiration date), so you never need to re-authenticate. This is the recommended method for regular export/docs/catalog MCP usage. It cannot create creator-owned template drafts.

Generate an API key from the dashboard, then pass it as a Bearer token. Most MCP clients handle this automatically when you add the server.

✓No token expiration — stable, long-lived sessions
✓Simple setup — just paste the key
✓Best for daily use and automation

OAuth (Browser Login)

Sign in with your Google or email account via WorkOS AuthKit. The access token is valid for 24 hours, after which you will need to re-authenticate. This identity-bound method is required for html2pptx_publish_template.

When you add the MCP server, your browser will open the login page automatically. Sign in to authorize.

✓No API key management needed
✓Good for quick trials and evaluation

OAuth sessions expire after 24 hours of inactivity. For uninterrupted access, we recommend using an API key instead.

Available MCP Tools

Tool	Description
`html2pptx_list_export_plans`	List the current commercial plan catalog and recommended plan.
`html2pptx_create_export_job`	Create an export job from HTML/CSS content. Supports optional width, height, layout, waitForCompletion, pollIntervalMs (1-60 seconds), timeoutMs (up to 300 seconds), and responseFormat ("url" \| "base64" \| "both"). Inline MCP delivery is limited to 2 MiB; larger files return the signed URL with a warning.
`html2pptx_import_pptx`	Remote MCP only. Reverse of export: convert an existing .pptx into editable HTML slides by passing pptxBase64. The local stdio MCP does not expose this tool or accept filePath. Resolves theme colors, master text styles, and fonts.
`html2pptx_get_export_job`	Get the current status of an export job by jobId.
`html2pptx_wait_for_export_job`	Polls every 1-60 seconds until the job completes, fails, or reaches the 300-second maximum wait. Transport and rate-limit errors are returned to the caller; the tool does not add automatic retries or backoff.
`html2pptx_get_docs`	Fetch html2pptx.app documentation to understand the API contract, HTML requirements, and integration guides.
`html2pptx_get_usage`	Fetch the current usage and quota status for your plan. Shows daily and monthly export counts, remaining quotas, plan limits, and reset information.
`html2pptx_list_templates`	List available marketplace templates with metadata and optional category filtering.
`html2pptx_get_template_html`	Fetch a template source HTML and design prompt so agents can study or remix it.
`html2pptx_validate_template_html`	Dry-run marketplace HTML validation after AI security preflight. Required before creating an HTML template draft.
`html2pptx_publish_template`	Upload validated HTML, infer missing title/description/category/tags, and create a creator-owned HTML draft. The tool returns draftUrl; the user can review it and create an unlisted share from the dashboard. New public-gallery publishing is currently disabled.
`html2pptx_open_local_slide_editor`	Local stdio MCP only. Starts the existing CLI localhost bridge for a local .html/.htm slide file and opens the no-code editor without publishing the HTML. Not available from remote /mcp because remote servers cannot access user files.
`html2pptx_stop_local_slide_editor`	Local stdio MCP only. Stops a local editor bridge session started by html2pptx_open_local_slide_editor.

MCP Resources (Documentation)

The MCP server provides documentation as Resources. Agents can read these before creating export jobs to understand the API contract and HTML requirements.

URI	Resource	Description
`docs://html2pptx/overview`	Service Overview	Architecture, CSS support, comparison with alternatives
`docs://html2pptx/quickstart`	Quickstart	First API call in 4 steps
`docs://html2pptx/api-reference`	API Reference	Endpoints, authentication, error codes
`docs://html2pptx/html-contract`	HTML Contract	HTML structure requirements and supported CSS
`docs://html2pptx/skills`	Skills Integration	Skill definitions for AI agents
`docs://html2pptx/mcp`	MCP Integration	MCP server setup and usage

llms.txt (AI-Optimized Docs)

html2pptx.app publishes documentation using the community-proposed llms.txt format. These Markdown resources summarize the service for AI agents and LLMs; llms.txt is not an official web standard.

https://html2pptx.app/llms.txt

Concise Markdown index — service overview, API contract, and supported CSS

https://html2pptx.app/llms-full.txt

Expanded Markdown documentation covering the public docs sections

Example Usage

1# Example conversation in Claude Desktop with html2pptx.app MCP:
2
3User: "Create a presentation about our Q1 2026 results."
4
5Claude (via MCP):
61. Calls html2pptx_list_export_plans to inspect available plans
72. Generates slide HTML from the conversation context
83. Calls html2pptx_create_export_job with the HTML payload
94. Calls html2pptx_wait_for_export_job to poll until completion
105. Returns the resulting PPTX payload or follow-up instructions
11
12# Behind the scenes, the MCP tools handle:
13# - Authentication with your configured API key
14# - Proper HTML contract formatting (.slide class, explicit slide dimensions)
15# - Status polling with exponential backoff
16# - Error handling and retry logic

CLI Tool

Install

Install globally

npm install -g html2pptx-cli

Or run directly with npx

npx html2pptx-cli convert slides.html

What is the CLI

The html2pptx CLI lets you convert HTML files to PowerPoint directly from your terminal, open local HTML in edit-slide, and browse templates. It supports both interactive mode (guided prompts for first-time users) and direct mode (flags for scripting, CI/CD, and AI agents like Claude Code). The supported public creator-owned HTML template-draft workflow uses authenticated remote MCP, and the CLI intentionally rejects draft creation. Legacy or hidden web surfaces are outside this public contract.

Initial Setup

Before converting files, configure your API key. This is a one-time setup that saves your credentials to ~/.html2pptx/config.json (owner-only permissions).

1html2pptx init

Commands

Command	Description
`html2pptx login`	Configure your API key interactively. Shows a link to the dashboard where you can generate a key.
`html2pptx logout`	Remove your stored API key from ~/.html2pptx/config.json.
`html2pptx convert [file]`	Convert an HTML file to PPTX. Run without arguments for interactive mode, or pass a file path for direct mode.
`html2pptx status`	Check your current usage, remaining quota, rate limits, and plan details.
`html2pptx whoami`	Verify your API key and show authentication status, plan name, and usage.
`html2pptx config`	Display current configuration (API key, base URL).
`html2pptx templates list`	Browse all available templates with title, category, and slide count.
`html2pptx templates get <id>`	Get template details including download URLs. Use --prompt for the design prompt, --html for source code.
`html2pptx templates publish`	Disabled. The supported public creator-owned HTML draft workflow uses authenticated remote MCP.
`html2pptx --help`	Show help and available commands.
`html2pptx --version`	Show the installed CLI version.

Convert Options

Flag	Description
`-o, --output <file>`	Output PPTX filename (default: input filename with .pptx extension)
`-s, --size <size>`	Slide size: "16:9", "4:3", or custom "WxH" (e.g. 1920x1080)
`--css <file>`	External CSS file to include alongside the HTML
`--json`	Output result as JSON for scripting and CI/CD pipelines
`--open`	Automatically open the PPTX file after conversion
`--base-url <url>`	API base URL (default: https://html2pptx.app)

Examples

Direct mode (for scripts & AI agents)

1# One-liner conversion
2html2pptx convert ./slides.html -o presentation.pptx -s 16: 9
3
4# With external CSS
5html2pptx convert ./slides.html --css ./styles.css -o deck.pptx
6
7# JSON output for scripting
8html2pptx convert ./slides.html --json
9# {"success":true,"file":"slides.pptx","size":"1.2 MB","duration":"3.2s"}

Interactive mode (for first-time users)

1# Just run convert without arguments
2html2pptx convert
3
4# The CLI will guide you through:
5#   > HTML file to convert
6#   > Slide size selection
7#   > Output filename

Account management

1# Check authentication
2html2pptx whoami
3#   Plan: Starter
4#   Usage: 1 / 120 exports today
5#   Remaining: 119
6
7# Check detailed usage
8html2pptx status
9#   Plan: Starter
10#   Daily Usage: 42 / 120 exports  ████████████░░░░░░░░
11#   Remaining: 78
12#   Rate Limit: 5 req/min
13#   Max Slides: 50 per job
14
15# Remove credentials
16html2pptx logout

Templates

1# List all templates
2html2pptx templates list
3
4# Get template with design prompt
5html2pptx templates get atlantis-pizza-corp --prompt
6
7# Get template with HTML source (JSON output)
8html2pptx templates get atlantis-pizza-corp --prompt --html --json
9
10# Supported public draft workflow (authenticated remote MCP):
11# AI security preflight -> html2pptx_validate_template_html -> html2pptx_publish_template -> dashboard review

Use Cases & Examples

html2pptx.app is designed for automated, repeatable slide generation. Here are the most common integration patterns:

Automated Quarterly Reports

Generate quarterly performance decks from live data. Pull metrics from your database, format them as slide HTML with charts and KPI cards, and export via the API. Schedule with cron or trigger from your BI pipeline, with validation and output review before distribution.

1const slides = quarterly_data.map((quarter, i) => `
2  <section class="slide" style="width: 1600px;height: 900px;padding: 60px;font-family:'Noto Sans JP',sans-serif;">
3    <h2 style="color:#1a1a2e;font-size: 36px;">Q${i+1} Results</h2>
4    <div style="display:grid;grid-template-columns: 1fr 1fr;gap: 40px;margin-top: 40px;">
5      <div style="background:#f0f4ff;border-radius: 16px;padding: 32px;">
6        <p style="font-size: 14px;color:#6b7280;">Revenue</p>
7        <p style="font-size: 48px;font-weight: 700;color:#1a1a2e;">${quarter.revenue}</p>
8      </div>
9      <div style="background:#f0fdf4;border-radius: 16px;padding: 32px;">
10        <p style="font-size: 14px;color:#6b7280;">Growth</p>
11        <p style="font-size: 48px;font-weight: 700;color:#16a34a;">${quarter.growth}%</p>
12      </div>
13    </div>
14  </section>
15`).join("\n");
16
17const resp = await fetch("/api/export/jobs", {
18  method: "POST",
19  headers: { "Authorization": "Bearer sk_live_xxxx", "Content-Type": "application/json" },
20  body: JSON.stringify({ fileName: "q-report.pptx", html: slides }),
21});

Sales Proposal Templates

Define brand-compliant slide templates in HTML/CSS once, then populate them with dynamic content for each campaign or client pitch. Variables like company name, project details, and pricing are injected at generation time. Marketing teams maintain the templates; teams review exported decks for brand and layout consistency before use.

1// Sales proposal template with dynamic client data
2function generateProposal(client) {
3  return `
4    <section class="slide" style="width: 1600px;height: 900px;padding: 60px;background:linear-gradient(135deg,#1a1a2e,#16213e);">
5      <h1 style="color:#fff;font-size: 48px;">${client.companyName} 御中</h1>
6      <p style="color:#a0aec0;font-size: 24px;margin-top: 20px;">ご提案書 - ${client.projectName}</p>
7      <div style="position:absolute;bottom: 60px;left: 60px;color:#718096;font-size: 14px;">
8        ${new Date().toLocaleDateString('ja-JP')} | Confidential
9      </div>
10    </section>
11    <section class="slide" style="width: 1600px;height: 900px;padding: 60px;">
12      <h2 style="font-size: 36px;color:#1a1a2e;">提案概要</h2>
13      <div style="display:grid;grid-template-columns: 1fr 1fr 1fr;gap: 30px;margin-top: 40px;">
14        ${client.features.map(f => `
15          <div style="background:#f7fafc;border-radius: 12px;padding: 24px;">
16            <h3 style="font-size: 20px;color:#2d3748;">${f.title}</h3>
17            <p style="font-size: 14px;color:#718096;margin-top: 8px;">${f.description}</p>
18          </div>
19        `).join('')}
20      </div>
21    </section>
22  `;
23}

Agent-Powered Presentations

Let AI agents create presentation decks from meeting notes, research summaries, or project briefs. Using Skills or MCP integration, the agent understands the html2pptx.app HTML contract, generates compliant slides, and delivers a download link. Users simply describe what they want in natural language.

SaaS Export Embedding

Add "Export to PowerPoint" functionality to your SaaS product. Render your app's dashboards, analytics views, or reports as slide HTML and call the html2pptx.app API from your backend. Users get native PPTX files with editable text and shapes -- not flat screenshots.

1// Backend route: POST /api/dashboard/export-pptx
2app.post("/api/dashboard/export-pptx", async (req, res) => {
3  const { dashboardId } = req.body;
4  const dashboard = await getDashboard(dashboardId);
5
6  // Render each widget as a slide
7  const slides = dashboard.widgets.map(widget => `
8    <section class="slide" style="width: 1600px;height: 900px;padding: 40px;">
9      <h2 style="font-size: 28px;color:#1a1a2e;">${widget.title}</h2>
10      <div style="margin-top: 20px;">${widget.renderToHTML()}</div>
11    </section>
12  `).join("");
13
14  // Call html2pptx.app API
15  const job = await fetch(process.env.HTML2PPTX_API_URL + "/api/export/jobs", {
16    method: "POST",
17    headers: {
18      "Authorization": `Bearer ${process.env.HTML2PPTX_API_KEY}`,
19      "Content-Type": "application/json",
20    },
21    body: JSON.stringify({
22      fileName: `${dashboard.name}.pptx`,
23      html: slides,
24    }),
25  });
26
27  const { jobId } = await job.json();
28  res.json({ jobId, statusUrl: `/api/export/jobs/${jobId}` });
29});

Plans & Pricing

Choose the plan that fits your usage. The current public catalog is defined in code and enforced in the API gateway: requests per minute, daily guardrails, maximum slides per job, concurrent jobs, API key count, and payload size all vary by plan.

Plan	Exports	Slides/Job	Support	Price
Free Preview	10 per month / 3 rpm	20 per job	Community	¥0
Founder Beta	300 per month / 5 rpm	50 per job	Self-serve	¥980/mo
Starter	3,000 per month / 15 rpm	100 per job	Email	¥2,980/mo
Business	20,000 per month / 60 rpm	200 per job	Priority	¥9,800/mo
Enterprise / OEM	Custom	500+ per job	Dedicated	¥49,800/mo〜

Upgrade anytime from the Dashboard. Changes take effect immediately with prorated billing. Downgrade at the end of the current billing period.

Rate Limits & Quotas by Plan

Each plan enforces the following limits. All channels (REST API, Skills, MCP) share the same quotas.

Plan	RPM	Daily	Monthly	Slides/Job	Concurrent	API Keys	Payload	Fair Use
Free Preview	3 req/min	10/day	10/mo	20 slides	1 job	1 key	1 MB	Hard cap at 10/mo — upgrade to continue
Founder Beta	5 req/min	50/day	300/mo	50 slides	2 jobs	3 keys	2 MB	Hard monthly cap (300/mo)
Starter	15 req/min	300/day	3,000/mo	100 slides	5 jobs	10 keys	5 MB	Hard monthly cap (3,000/mo)
Business	60 req/min	2,000/day	20,000/mo	200 slides	20 jobs	50 keys	10 MB	Hard monthly cap (20,000/mo)
Enterprise / OEM	120 req/min	Custom	Custom	500 slides	50 jobs	100 keys	25 MB	Custom terms

* Remote MCP export tools use the plan RPM. Read-only tools use 30 requests/min per authenticated subject. Template publishing and validation use separate deployment-configurable limits (defaults: 5 and 12 requests/min). Protocol messages such as initialize and tools/list are not charged to these tool limits.

Security & Limits

Public API, Skills, MCP, Studio, and hosted web export are all routed through the same security-sensitive conversion pipeline. The practical controls below are the ones that matter when you integrate or expose the product.

Authentication and authorization

REST API uses API keys. Remote MCP supports commercial API keys or WorkOS-backed authenticated sessions. Job lookup is bound to the same API key or authenticated principal that created the job.

SVG and untrusted markup

Public API and MCP sanitize incoming HTML. Inline SVG is converted to PNG images for reliable output.

Worker isolation

Export jobs run in isolated contexts with enforced request body limits and automatic cleanup of expired jobs.

Usage controls

Per-minute rate limiting, daily guardrails, monthly fair-use review thresholds, maximum slides per job, maximum payload size, and concurrent job limits are all enforced server-side based on the active plan.

Recommended production practices

Treat API keys as secrets and rotate them from the dashboard when they are exposed.
Use the REST API for backend automation and same-origin hosted web export only for first-party browser flows.
Poll the public job status route with backoff instead of hammering the status endpoint.
Keep slide markup deterministic: explicit slide dimensions, predictable CSS, and no runtime-dependent content. 1600x900 remains the default example.
MCP embeds completed PPTX files only up to 2 MiB. Larger files—including explicit responseFormat: "base64" or "both" requests—return a signed download URL plus a machine-readable warning instead of an oversized response.
Remote /mcp accepts at most 32 JSON-RPC messages and one tools/call message per authenticated HTTP POST. Send additional tool calls separately so the server can enforce the correct per-operation rate limit.
For agent integrations, decide whether the client should use local stdio MCP or remote /mcp before rollout.

FAQ

How is html2pptx.app different from other HTML-to-PPTX solutions?

html2pptx.app maps supported text, simple shapes, tables, and CSS properties to PowerPoint objects instead of rendering every slide as one screenshot. Inline SVGs, icons, and some complex lists are rasterized. Output follows the published HTML contract and should be visually reviewed after export.

Can I convert any HTML to PPTX?

Not reliably. html2pptx.app is optimized for slide-oriented HTML with .slide class elements and explicit dimensions. 1600x900 is the default example, but portrait and other custom sizes are also supported. Arbitrary web pages, interactive apps, scroll-based layouts, and pages with JavaScript-dependent rendering are not supported. The HTML contract section describes the exact requirements.

What becomes a separate slide?

Each element with the .slide class becomes one slide in the output PPTX. If your HTML contains 5 elements with class="slide", the output will have 5 slides. Define clear slide boundaries for predictable results.

Will exported content remain editable in PowerPoint?

Supported text becomes editable PowerPoint text boxes, and supported simple shapes remain adjustable. Inline SVGs, detected icons, and some complex structures are exported as images, so those parts are not editable as text or vectors.

How long does export take?

Export time varies with slide count, layout complexity, and image processing. Poll the job status endpoint with a plan-safe interval, honor Retry-After after a 429 response, and stop when the job reaches completed or failed.

Which fonts are supported?

System fonts such as Arial, Helvetica, and Times New Roman can be used when available in the renderer and target PowerPoint environment. Public REST removes @font-face rules and blocks external font downloads, so autoEmbedFonts does not fetch Google Fonts or arbitrary web-font URLs on this path. Use a suitable font stack and verify substitutions, glyph coverage, and wrapping.

Is there a free plan?

Yes. Free Preview includes one API key and up to 10 exports per month, with limited API, Skills, and MCP usage. Check GET /api/export/plans for the current plan metadata because limits are enforced from code and may evolve.

Can I use SVGs in my slides?

Yes. Inline SVG is supported and converted to a PNG image. Review the generated PPTX in the target PowerPoint environment because rendering and image scaling can vary.

What is the maximum file size?

The HTML payload should stay under 5MB. Generated PPTX files vary by content but typically range from 100KB to 10MB. Jobs with many high-resolution images embedded as base64 will produce larger files. Consider using URL references for large images.

How secure is the service?

html2pptx.app implements multiple security layers: jobs are bound to the creating principal; API keys are hashed at rest; request body limits and concurrent job limits are enforced server-side. Use the REST API for server-side automation and treat hosted web export as a browser surface.

Does html2pptx.app support Japanese text and CJK characters?

Japanese, Chinese, and Korean text is supported. Specify a CJK font stack in CSS (for example, font-family: "Noto Sans JP", sans-serif) and verify glyph coverage and line wrapping in the target PowerPoint environment because installed fonts and metrics can differ.

How do I handle errors?

Check the job status endpoint. If status is "failed", the error or message field contains a human-readable description. Commercial export errors use RFC 9457 Problem Details fields plus legacy error and message fields; some legacy and creator endpoints return a smaller JSON error object. Common issues: missing .slide elements (400), invalid or missing API key (401/403), rate limit exceeded (429), and oversized content (413).

Can I use CSS Grid for complex slide layouts?

The supported CSS Grid subset includes grid-template-columns, grid-template-rows, gap, and grid placement properties. Use explicit slide dimensions and inspect the exported PPTX, because complex browser layouts or unsupported property combinations may render differently.

Is there a webhook for job completion?

Yes. Add callbackUrl (HTTPS only) to POST /api/export/jobs. The notification contains jobId/status plus fileName on success or message on failure, but it is only a delivery hint. No customer-verifiable webhook signing contract is currently exposed, so treat the callback as unauthenticated and fetch the complete result from the authenticated GET /api/export/jobs/{jobId}. Keep status polling as the source of truth, use a plan-safe interval, and honor Retry-After after 429 responses. MCP users can use html2pptx_wait_for_export_job for interval polling; transport and rate-limit errors are returned to the caller.

Troubleshooting

Issue	Solution
Job stuck in "queued" status	The private worker may be offline or overloaded. Wait 30 seconds and retry. If persistent, check worker health from the Dashboard or contact support.
Slides appear blank	Ensure your HTML contains elements with class="slide" and that those elements have visible content. Also verify that CSS is included in the payload and not relying on external stylesheets.
Fonts look different in PPTX	Public REST does not fetch external web fonts. Use a font stack available in both the renderer and target PowerPoint environment, then inspect substitutions and wrapping.
429 Rate limit error	Honor the Retry-After header when present and increase the interval between status requests. Upgrade your plan if the documented request limits are too low.
Layout differs from browser preview	Use explicit dimensions on .slide elements with inline styles. 1600x900 is the default example, but custom aspect ratios also work when your slide HTML and requested width/height/layout match. Avoid responsive/percentage-based layouts, media queries, and viewport-relative units (vh, vw).
Images not appearing in PPTX	Use absolute URLs (https://...) or base64 data URIs for images. Relative paths and localhost URLs will fail. Ensure image URLs are publicly accessible from the worker.
PPTX file size is too large	Large files are usually caused by embedded base64 images or image-heavy content. Use URL references instead, or compress images before embedding.