AI agent PowerPoint API: which presentation API your agent can actually call
Updated 2026-09-05 · ~9 min read · Guide
Nearly every presentation API now ships an MCP server, so “has MCP” has stopped being the thing that separates them. What still separates them is whether an agent — a program with no eyes on the result — can authenticate on its own, express a layout as typed data rather than a prose prompt, and read back a verdict saying whether the slide is usable. slideforge.dev is built for those three. Below: what an agent actually needs, how the current field compares on exactly those axes, and a worked agent loop you can run today.
TL;DR
- MCP is table stakes now. SlideSpeak, 2Slides and Presenton all have one. Pick on auth, determinism and verifiability instead.
- Auth the agent completes alone. slideforge.dev uses OAuth 2.1 discovery from one URL — no key provisioned by a human, no shim process.
- Typed contract, not a prompt. Your agent already holds structured data. Pick a
formfrom 200+ layouts and send the fields; they bind verbatim with zero LLM in the render path. - A verdict it can branch on. Every render returns status, fidelity and per-field warnings, so the agent knows whether to ship or retry without rendering an image and looking at it.
- Synchronous. Under a second per slide, ~4s for a 5-slide deck. No job polling, no webhook receiver. $0.05 per slide, 60 free.
What an agent needs that a person doesn't
Most presentation APIs were designed around a person who will look at a preview and fix what's wrong. Take the person out of the loop and three gaps open up.
1. Auth it can complete by itself
An API key is a secret a human has to create, paste into a config file, and rotate. That is fine for a service you deploy once and forget; it is friction every time an agent meets a new tool. With OAuth 2.1 discovery the agent is handed a URL, gets redirected once, and is connected — the credential never sits in a file. slideforge.dev serves https://api.slideforge.dev/mcp/ that way. A key still works for CI and headless runs where no browser exists.
2. A typed contract instead of a prose prompt
An agent arrives holding structured data — rows, metrics, dates, stages. An API that accepts only a text prompt makes it flatten that structure into a paragraph and hope a model reconstructs it. slideforge.dev goes the other way: the agent reads the form menu — browse_catalog over MCP, GET /v1/catalog/forms over REST, free and unauthenticated either way — picks a form, pulls that form's JSON Schema and capacity limits, then sends the fields it declares. Your numbers land in the file exactly as sent, because no language model runs in the render path.
3. A verdict it can branch on
The agent is not looking at the slide. If a 90-character label was quietly shortened to fit, or a fourth column was dropped because the layout holds three, an HTTP 200 and a download link tell it nothing. Every slideforge.dev render returns status, fidelity and per-field warnings. The agent ships on verbatim, and on a truncation warning either shortens the text or re-renders into a layout with more capacity — a decision it can make in code.
The field, on the axes an agent cares about
Checked 2026-09-05 against each vendor's own documentation: SlideSpeak's MCP README documents npx mcp-remote or Docker with a Bearer API key; 2Slides documents a JSON-RPC 2.0 endpoint at /api/mcp with an sk-2slides-key and an async job-polling flow; Presenton's API page states MCP is exposed by self-hosted deployments. Pricing is deliberately left out — it changes faster than this page does; check each vendor. Ours is below. If something here is out of date, tell us and we will correct it.
A worked agent loop
Three steps: choose a layout, render it, read the verdict. Only the render costs anything — discovery is free and needs no auth, so an agent can read the whole contract before it spends a cent.
# 1. Free, no auth: the form menu — what each layout is for and what it binds.
curl -s https://api.slideforge.dev/v1/catalog/forms
# Then one form's JSON Schema, capacity limits and worked examples:
curl -s https://api.slideforge.dev/v1/catalog/forms/kpi_metrics
# 2. $0.05: bind the agent's own numbers into that form. No LLM runs here.
curl -s -X POST https://api.slideforge.dev/v1/render/intent \
-H "Authorization: Bearer sf_live_..." \
-H "Content-Type: application/json" \
-d '{
"form": "kpi_metrics",
"headline": "Q3: all KPIs trending up",
"data": {"metrics": [
{"value": "$12.4M", "label": "Revenue", "trend": "+18%"},
{"value": "847", "label": "New Clients","trend": "+12%"},
{"value": "94%", "label": "Retention", "trend": "+2pp"}
]}
}'
# 3. The response the agent branches on:
# {
# "status": "complete",
# "fidelity": "verbatim", <- every field landed as sent; ship it
# "warnings": [], <- non-empty means shorten or re-route
# "job_id": "job_..."
# }Over MCP the same loop is plan_slide → create_slide, with the fidelity report returned to the agent as tool output. For a whole deck, hand create_deck N intents at once — they render in parallel and compile into one .pptx, synchronously.
Which one should you point your agent at?
slideforge.dev — the deck ships unattended, so the output has to be verified rather than merely generated, and your agent already holds the structured data it wants on the slide.
python-pptx — you want no vendor at all, you are happy writing and maintaining ~30–100 lines of layout code per slide, and nothing needs to check the result. Still the most-recommended answer in this category for a reason. See the head-to-head.
Presenton — you need the whole thing inside your own infrastructure and are willing to run and update it.
SlideSpeak or 2Slides — a prose prompt really is your input, a human reviews the deck before it goes out, and an async job flow with an API key fits your stack.
What it costs on slideforge.dev
- Any render — typed intent, brief, or your own python-pptx: $0.05 per slide
plan_slideandbrowse_catalog: free- Identical input re-sent: free
- A render that comes back unusable: not billed
60 free slides on signup, no card. No subscription — a USD wallet with a $10 minimum top-up. Full pricing.
Frequently asked questions
What does an AI agent need from a presentation API that a human doesn't?
Three things. (1) Auth it can complete without a human pasting a secret — OAuth 2.1 discovery means the agent hits the MCP URL, gets redirected once, and is connected; an API key in a config file has to be provisioned by a person first. (2) A typed contract instead of a prose prompt — an agent already holds structured data, so asking it to write a paragraph describing a chart and hoping a model draws the right one throws away the structure it has. (3) A machine-readable verdict — the agent is not looking at the slide, so the response has to say whether the content fit, what was truncated, and what was dropped, or the agent cannot decide whether to retry. Most presentation APIs were built for a person watching a preview and provide none of the three.
Which presentation APIs have an MCP server in 2026?
Most of the category now does, so MCP support on its own no longer separates them. slideforge.dev serves a hosted MCP endpoint at https://api.slideforge.dev/mcp/ with OAuth 2.1. SlideSpeak serves one at mcp.slidespeak.co, connected through npx mcp-remote or a Docker image with a SlideSpeak API key in the header. 2Slides documents a JSON-RPC 2.0 MCP endpoint at /api/mcp with a Bearer key. Presenton exposes an MCP server on self-hosted deployments. python-pptx is a library, not a service, so there is nothing to connect to. The differences that remain are in how the agent authenticates, whether the render is deterministic, and whether the response tells the agent what happened.
Why does determinism matter for an agent pipeline?
Because a retry has to be a fix, not a dice roll. If an LLM authors the slide, the same input can produce a different layout on the second call, so an agent that retries after a bad render cannot tell whether its change helped. slideforge.dev binds typed fields verbatim with zero LLM in the render path: the same intent produces the same .pptx, so when the agent changes one field it can attribute the difference to that field. Prose briefs are routed to a form first, then rendered the same deterministic way.
What is a fidelity report and what does the agent do with it?
Every slideforge.dev render returns status, fidelity, and warnings per bound field — whether each value landed verbatim, was shortened to fit, or was dropped because the chosen layout had no room for it. An agent branches on that: fidelity verbatim means ship it, a truncation warning means either shorten the text or re-render into a layout with more capacity. Without it the agent has to render the slide to an image and look at it, which is slower, costs more, and is exactly the check it should not have to do.
Can my agent generate a whole deck in one call?
Yes. POST N slide intents to /v1/render/intent/deck (or call create_deck over MCP) and they render in parallel and auto-compile into a single .pptx. A 5-slide deck takes roughly 4 seconds end to end at $0.05 per slide. The call is synchronous — the response carries the deck URL, so the agent does not maintain a polling loop or a webhook receiver.
How do I connect an agent to slideforge.dev?
Add one URL, https://api.slideforge.dev/mcp/, to your MCP client — Claude Desktop, Claude Code, Cursor, VS Code with Copilot, Codex CLI, Windsurf, or any MCP-compatible runtime. OAuth runs on first use, so no API key is stored in a config file. The agent then has create_slide, create_deck, plan_slide, browse_catalog, translate_deck, upload_asset and manage_account. For CI and headless runs where no browser is available, an API key in an Authorization header works instead.
Connect your agent
Client-specific setup, each about a minute: Claude Code, Claude Desktop and claude.ai, Cursor, VS Code + Copilot, Codex CLI, ChatGPT, or n8n if the workflow has no agent in it at all. The REST surface is documented in the PowerPoint API guide.
Give your agent one URL.
https://api.slideforge.dev/mcp/ — OAuth on first use, 60 free slides, no card.
Canonical: slideforge.dev/guides/ai-agent-powerpoint-api. SlideForge is published by Smart Data Brokers GmbH, Zurich. Competitor capabilities are described from each vendor's own public documentation as of 2026-09-05.