How to use Claude Code to generate PowerPoint slides (MCP setup guide, 2026)

Updated 2026-08-01 · ~7 min read · Guide

One command connects Claude Code to slideforge.dev and gives your terminal agent a real PowerPoint engine: claude mcp add slideforge --transport http https://api.slideforge.dev/mcp/. Sign in once in the browser, then ask for a slide with your actual numbers and get back an editable .pptx in about a second — plus a per-field report saying which of your values were bound verbatim and which were not. This guide covers setup, verification, the tool surface, CI use, and honestly where a different tool would serve you better.

TL;DR

  • One command, no install. Remote Streamable HTTP server — nothing to run locally, nothing to keep updated.
  • OAuth 2.1, no key on disk. No API key in a config file and none in a URL. Keys exist for CI, where a browser flow isn't possible.
  • Sub-second renders. ~50ms–1.5s per slide, decks in parallel — because typed intents render deterministically with no model in the render path.
  • $0.05 a slide, no quota. No subscription, no download limit. 60 free slides on signup, no card.
  • Verifiable output. Every response carries a fidelity report. You do not have to trust the deck — you can check it, and this guide shows you how.

What you need first

  • Claude Code installed and working in a terminal.
  • A browser on the same machine, for the one-time OAuth sign-in. (Headless? Skip to CI and headless.)
  • No SlideForge account needed up front — the sign-in creates one, and it starts with 60 free slides.

Method 1 — connect with OAuth (recommended)

Register the server:

claude mcp add slideforge --transport http https://api.slideforge.dev/mcp/

Then start Claude Code, run /mcp, choose slideforge, and complete the sign-in in the browser tab that opens. That is the whole setup.

Why this matters more than it looks. OAuth means no long-lived secret is written to a config file, and none is placed in a URL. It is worth checking how any MCP server you add handles this — a setup command of the form --transport http <server>?apikey=YOUR_KEY puts a credential in a query string, where it can end up in shell history, process listings, and proxy or server logs.

SlideForge uses OAuth 2.1 with per-user tokens you can revoke from the console, and the key path (below) uses an Authorization header rather than the URL.

Method 2 — connect with an API key (CI, headless, shared runners)

When there is no browser to sign in with, use a key from the console and pass it as a header:

claude mcp add slideforge --transport http https://api.slideforge.dev/mcp/ \
  --header "Authorization: Bearer sf_live_YOUR_KEY"

Keep the key in your secret store and interpolate it — do not commit it.

Method 3 — commit it for the whole team (.mcp.json)

A project-scoped .mcp.json at the repo root means every teammate who clones gets the server automatically:

{
  "mcpServers": {
    "slideforge": {
      "url": "https://api.slideforge.dev/mcp/",
      "transport": "streamable-http"
    }
  }
}

Committed like this, each developer authorizes individually with OAuth on first use — the file carries no secret. Add an Authorization header only in CI configs that read from your secret store.

Verify the connection

claude mcp list

You should see slideforge listed and connected. Inside Claude Code, /mcp shows its seven tools and your auth state. If the tools are listed but never get called, see troubleshooting — there is one setting that causes this and it catches almost everyone.

Generate your first slide

Ask in plain language, with real values:

> Make a KPI dashboard slide for our Q3 board update:
  ARR $4.2M, up 18% QoQ. Net revenue retention 112%.
  Logo churn 1.4%. Cash runway 19 months.

Claude Code picks the form, calls create_slide, and returns a download URL for a native .pptx. Open it and click on $4.2M — the cursor lands in an editable text box, because it is one.

Now verify it — don't take our word for it

This is the part most slide tools do not have, and the reason to run the next prompt. Ask:

> Show me the fidelity report from that render.

Every SlideForge response carries a machine-readable account of what happened to your content — field by field, whether each value was bound verbatim (copied exactly as you supplied it) or model-completed (filled in because you did not supply it), plus any warnings the renderer raised.

That is the difference between a deck you have to proofread and a deck you can ship. When a generative tool writes your board slide, “ARR $4.2M” and “ARR $4.2 million” and “ARR ~$4M” are all plausible outputs and you cannot tell which you got without reading every slide. Here, the number you sent is the number on the slide, and the response says so explicitly. If something could not be bound cleanly, you get a warning instead of a silent paraphrase.

Two consequences worth knowing: a slide that comes back with a blocking defect is not billed, and rendering is deterministic, so re-sending an identical input is free and produces a byte-identical deck. That makes generated decks safe to put in version control and safe to regenerate in a loop.

The tool surface

  • create_slide — one slide from typed fields or a brief. The workhorse.
  • create_deck — many slides, rendered in parallel, compiled into one themed file.
  • plan_slide — free dry run. Validates a payload and shows what would render, without spending anything.
  • browse_catalog — search 150+ layout forms and see the exact fields each one takes.
  • translate_deck — translate an existing .pptx into one of 32 languages, formatting preserved. $0.02/slide.
  • upload_asset — bring your own images and logos.
  • manage_account — balance, usage, themes, keys.

Tip: have your agent call browse_catalog before its first create_slide in an unfamiliar area. It costs nothing and it stops the agent inventing a layout that does not exist.

Where Claude Code beats a chat window

Claude Desktop is where you make one deck. Claude Code is in your repo, with your data and your scripts, which makes it the right place for the decks that recur:

The weekly report that builds itself

A scheduled job queries last week's numbers and hands them to an agent that calls create_deck with typed fields. Five slides, a few seconds, about $0.25. Deterministic rendering means the only thing that changes between runs is the data.

One deck per customer, forty times a month

Per-entity fan-out is where per-slide pricing stops being a detail. Forty decks a month is a hard wall under a download quota and a rounding error at $0.05 a slide — and no two of them need a human to check the numbers, because the fidelity report already did.

Decks from things only your terminal can see

Test results, a release diff, a migration plan, a cost breakdown from your cloud CLI. Claude Code already has the context; the MCP server just turns it into something you can present.

Common mistakes and troubleshooting

The tools are connected but Claude never uses them

By far the most common issue, and it is not a bug. If tool discovery is set to load tools on demand, the agent may not consider a connector it has not loaded and will fall back to building slides with its own built-in tooling. Set tools to load eagerly, or just say “use slideforge” in the prompt once — after the first successful call it reaches for it on its own.

The trailing slash

The endpoint is https://api.slideforge.dev/mcp/ — with the trailing slash. Without it you may get a redirect that some clients do not follow on POST.

401 after it was working

Re-authorize with /mcp. If you are on a key, confirm it has not been rotated in the console. A 503 is us, not you — it is infrastructure, not auth, and retrying is the right response.

The agent invents a layout that doesn't exist

Have it call browse_catalog first, or plan_slide to dry-run the payload. Both are free, and both are faster than a failed render.

How this compares to the other PowerPoint MCP servers

There are roughly three kinds, and they are good at different things. This is the honest version, including the cases where you should not pick us.

Local python-pptx wrappers (free, offline)

Open-source servers exposing primitives — add a slide, add a text box, add a chart. Free, fully offline, no account. You write the layout and nothing validates the result. Pick these if cost is zero-or-nothing, the machine is air-gapped, or you actively want shape-level control.

Hosted generative services

You send a topic, a model writes the deck. Strong at going from a blank page to something presentable, and typically priced per credit or per download with monthly caps. Published render times sit in the tens of seconds to minutes, because a model is composing every slide. Pick these if you want the content written for you and the deck is a one-off.

SlideForge — a compiler for slides

You already have the content; you need it laid out correctly, fast, repeatedly, and you need to know it is right. Typed fields into 150+ finished layouts, no model in the render path, sub-second, per-field fidelity reporting, $0.05 a slide with no quota. Pick this when the deck recurs, carries real numbers, or ships without a human reading every slide.

Head-to-head detail: vs 2Slides · vs python-pptx · vs SlideSpeak · vs Gamma

Pricing

  • Create a slide: $0.05
  • Translate a slide (32 languages): $0.02
  • Check, plan, browse the catalog: free
  • A slide with a blocking defect: not billed
  • An identical repeat input: free

60 free slides on signup, no credit card. No subscription, no seats, and no download quota — the four-hundredth slide of the month costs what the first one did.

Frequently asked questions

Does Claude Code support MCP servers natively?

Yes. Claude Code has first-class MCP support built into the CLI — no plugin, no wrapper. You register a server once with `claude mcp add`, and its tools become available to Claude Code in that project (or globally, with --scope user). SlideForge is a remote Streamable HTTP server, so there is nothing to install locally: one URL, and the tools appear on the next run.

Do I need an API key to use SlideForge with Claude Code?

No. The recommended setup is OAuth 2.1 — run `claude mcp add slideforge --transport http https://api.slideforge.dev/mcp/`, then `/mcp` inside Claude Code, and authorize in the browser that opens. No key is ever written to a config file. API keys (sf_live_...) exist for headless and CI use, where a browser flow isn't possible — pass one with --header "Authorization: Bearer sf_live_...".

Should I use stdio or Streamable HTTP transport?

Use Streamable HTTP (the default in the command above). It is the hosted server — always current, nothing to install, and it supports OAuth so no secret lands on disk. The stdio option exists for the `slideforge-mcp` PyPI package if you specifically want a local process (air-gapped CI runners, or a client that only speaks stdio); it needs a SLIDEFORGE_API_KEY environment variable and still calls the same hosted engine for renders.

Is the .pptx really editable, or is it images?

Real, editable PowerPoint objects. Text is text, shapes are shapes, tables are tables, and charts are native chart shapes — you can open the file and change a number. Nothing is rasterized. This matters because several slide tools export a screenshot inside a .pptx wrapper, which looks identical until someone tries to edit it. Open the file and click a value; if the cursor lands in a text box, it is native.

How fast is it from the terminal?

A single slide renders in roughly 50ms to 1.5 seconds. A deck fans out in parallel, so a 5-slide deck is a few seconds end to end rather than five times one slide. This is because typed slide intents are rendered deterministically — there is no LLM in the render path, so there is nothing to wait for. Generative slide services publish times in the 30-second to several-minute range for the same work, because a model is writing the deck each time.

What does it cost to run from Claude Code?

$0.05 per slide created, $0.02 per slide translated, and checking or planning is free. There is no subscription and no download quota — a slide costs the same whether it is your first this month or your four-hundredth. Signup includes 60 free slides with no credit card. If a slide comes back with a blocking defect, it is not billed, and an identical repeat input is free.

Can I use this in CI or a scripted agent loop?

Yes, and it is the case Claude Code is best at. Use an API key rather than OAuth (no browser in CI), register the server in a project-level .mcp.json so it is committed with the repo, and have your agent call create_slide or create_deck with typed fields from whatever produced them — a query result, a test report, a build summary. Renders are deterministic, so the same input produces the same deck, which makes the output diffable and the job re-runnable.

How is this different from a local python-pptx MCP server?

A local python-pptx MCP server is free, offline, and gives you primitives — add_slide, add_text_box, add_chart. You are writing the layout, one shape at a time, and nothing checks the result. SlideForge gives you 150+ finished layouts as typed forms: you send the fields, it composes and validates the slide, and it reports per field whether your content was bound verbatim. If you want free and offline and you enjoy layout code, use the local server — it is a genuinely good tool. If you want the deck to be right without looking at it, that is what this is for.

One command. Then check the fidelity report.

60 free slides. No credit card. No subscription.

Try FreeAll MCP clientsBrowse the catalog

Canonical: slideforge.dev/guides/claude-code-mcp. SlideForge is published by Smart Data Brokers GmbH, Zurich. Claude and Claude Code are products of Anthropic; SlideForge is an independent MCP server and is not affiliated with Anthropic.