Prerequisites

• An editide account with an active subscription — sign up here and subscribe to a plan.
• Microsoft PowerPoint (Windows, Mac, or web).
• The add-in works on the web version of PowerPoint, but we recommend a desktop version for the best performance.
• Not available on mobile or iPad versions of PowerPoint.

Install for yourself (recommended)

The fastest way to get editide if you're setting it up for your own account.

Open in PowerPoint

Jumps straight to the install prompt in desktop PowerPoint. Your browser will ask for permission to open PowerPoint first.

1

In PowerPoint, go to the Home tab and click Add-ins. You can also click File and locate the Get Add-ins button.

2

Search for editide in the store, then click Add.

3

Accept the license terms and privacy policy to finish installing.

Deploy across your organization (administrators)

If you're a Microsoft 365 administrator, you can roll editide out to other people from the Microsoft 365 Admin Center.

1

Open the editide add-in on the Microsoft Marketplace, click Get it now, and sign in with your work account. You can also start from the Microsoft 365 Admin Center → Settings → Integrated apps → Get apps.

2

Select the users to add:

• Just me — your account only
• Entire organization — everyone in your tenant
• Specific users/groups — a subset of your organization

3

Review the settings and deploy. editide appears for assigned users under Home → Add-ins in PowerPoint within minutes (a full organization rollout can take up to 24 hours).

Contact support@editide.com if you have any issues.

The session lifecycle

Every file you upload opens a short-lived session, identified by a file_id.

The session and its files are deleted 8 hours after upload, so treat a file_id as temporary. See Endpoints for the full call surface and Quick Start for a working example.

Base URL

All endpoints are served from a single host:

https://cloud.editide.com

Keys at a glance

See Authentication for more detail.

Interactive API reference

For a live reference — endpoints, request/response schemas, and test calls in your browser — use the interactive explorer: Open API Explorer.

You can also retrieve the tool schemas programmatically:

GET https://cloud.editide.com/api/tools

Returns a JSON array of all available PowerPoint tools with their parameter schemas.

Prerequisites

• An editide account with an active API subscription — sign up here.
• An API key from the dashboard.

Edit endpoint

FILE_ID=$(curl -s https://cloud.editide.com/api/presentations \
  -H "X-Api-Key: eid_your_key_here" \
  -F "file=@deck.pptx" | jq -r .file_id)

curl -s https://cloud.editide.com/api/presentations/$FILE_ID/edit \
  -H "X-Api-Key: eid_your_key_here" \
  -H "X-Anthropic-Key: sk-ant-..." \
  -H "Content-Type: application/json" \
  -d '{"instruction":"Add a summary slide at the end", "model":"sonnet"}'

curl -s https://cloud.editide.com/api/presentations/$FILE_ID \
  -H "X-Api-Key: eid_your_key_here" \
  -o result.pptx

You can edit repeatedly before downloading. Each /edit continues the conversation — the agent remembers earlier instructions. To start a new conversation, upload a new presentation.

Tool call

FILE_ID=$(curl -s https://cloud.editide.com/api/presentations \
  -H "X-Api-Key: eid_your_key_here" \
  -F "file=@deck.pptx" | jq -r .file_id)

curl -s https://cloud.editide.com/api/tools/edit_slide \
  -H "X-Api-Key: eid_your_key_here" \
  -H "Content-Type: application/json" \
  -d '{
        "presentation_id": "'"$FILE_ID"'",
        "slide_index": 1,
        "slide": {
          "text_elements_to_add": [
            { "position": {"left": 40, "top": 320},
              "text_component": {
                "paragraph_list": [
                  { "runs": [ {"text": "Hello, world"} ] }
                ]
              } }
          ]
        }
      }'

curl -s https://cloud.editide.com/api/presentations/$FILE_ID \
  -H "X-Api-Key: eid_your_key_here" \
  -o result.pptx

editide API key

Required for every request. It identifies your account and tracks usage.

X-Api-Key: eid_your_key_here

Generate keys from the dashboard. Each key works with both the REST API and the MCP endpoints.

LLM API key (BYOK — edit endpoint only)

The /edit endpoint runs an AI agent that needs an LLM provider. This is the only endpoint that requires a third-party API key. Bring your own key in one of three shapes — send exactly one shape per request:

Claude

X-Anthropic-Key: sk-ant-...

OpenAI

X-OpenAI-Key: sk-...

Amazon Bedrock

X-AWS-Access-Key-Id: ...
X-AWS-Secret-Access-Key: ...
X-AWS-Region: ...
X-AWS-Session-Token: ...   # optional

Sending more than one shape, or a partial AWS triple, returns 400. AWS keys can be used to access both Claude and GPT models.

How keys are scoped

Keys belong to an account, and limits are enforced per account rather than per key. Minting additional keys does not raise your rate limit — every key draws from the same budget. Use separate keys to isolate environments or rotate credentials, not to buy headroom. For more, see Rate Limits.

Tools that make a slide billable

A slide becomes billable only when a tool changes its content. Reading, inspecting, reordering, and deleting won't make a slide billable.

See the tool catalog for the list of tools that don't make a slide billable. Those tools not listed above are free to call (subject to rate limits).

How billable slides are counted

• Editing the same slide many times before delivery counts as one slide.
• One request that changes ten slides counts as ten — billing is per slide, not per call or per turn.
• The count resets at delivery. Re-downloading an unchanged file is free; editing a slide again after a delivery bills it again on the next one.

Delivery: downloads and merges

Two operations deliver slides and settle the count:

• Download (most common) — GET /api/presentations/{file_id} delivers every modified slide since that file's last delivery.
• Merge — POST /api/presentations/merge delivers the modified slides from each source file at merge time, not just the slides in the merged result.

After either, those slides are settled: retrieving the same file again with no new edits is free.

Plan limits

Your plan also sets a monthly slide allowance. Reaching it returns 402 Payment Required; this is a plan limit, separate from the per-minute throttling covered in Rate Limits.

Some plans additionally cap monthly operations — direct tool and read calls made through the REST tool endpoints and MCP — and exceeding that cap also returns 402 Payment Required, asking you to upgrade.

Presentations

Upload a presentation

POST /api/presentations

Send a multipart form with a single file field (.pptx). Returns { "file_id": ..., "filename": ... }; the file_id identifies the session for subsequent calls. The maximum file size depends on your plan — see Files & Limits.

FILE_ID=$(curl -s https://cloud.editide.com/api/presentations \
  -H "X-Api-Key: eid_your_key_here" \
  -F "file=@deck.pptx" | jq -r .file_id)

Create a blank presentation

POST /api/presentations/new

Creates a blank 16:9 deck (one empty title slide) with no file to upload, and returns { "file_id": ..., "filename": ... } — usable with every other endpoint exactly like an upload. The body is optional; send { "filename": "pitch.pptx" } to name it, or nothing for untitled.pptx.

FILE_ID=$(curl -s https://cloud.editide.com/api/presentations/new \
  -H "X-Api-Key: eid_your_key_here" \
  -X POST | jq -r .file_id)

Edit a presentation

POST /api/presentations/{file_id}/edit

Run an AI agent that edits your .pptx file. This is the only endpoint that requires an LLM key, and must be sent on every /edit call — it is never stored between requests (see Authentication). The call is synchronous — it returns when the agent completes the task.

Body:

The model must match the LLM key you send: an Anthropic key pairs with the Claude models (haiku / sonnet / opus), an OpenAI key pairs with the GPT‑5.6 family (luna / terra / sol), and AWS Bedrock credentials work with any of the six. Kimi K2.6 and K3 are add-in only.

A second /edit sent while one is still running on the same file returns 409 — wait for the first to finish.

curl -s https://cloud.editide.com/api/presentations/$FILE_ID/edit \
  -H "X-Api-Key: eid_your_key_here" \
  -H "X-Anthropic-Key: sk-ant-..." \
  -H "Content-Type: application/json" \
  -d '{"instruction":"Add a summary slide at the end", "model":"sonnet"}'

Returns a JSON summary of the turn:

Total input the model processed = input_tokens + cache_creation_tokens + cache_read_tokens. The agent caches the system prompt, tool schemas, and slide context, so a warm turn typically shows a small input_tokens and a large cache_read_tokens.

Each call on the same file_id reuses the conversation context, so the agent remembers prior instructions.

You can switch models between calls within the same provider (e.g. sonnet → opus), but switching providers mid-conversation (Anthropic ↔ OpenAI) returns 400; upload the file again to start fresh under the new provider.

Download a presentation

GET /api/presentations/{file_id}

Streams back the current .pptx. Modified slides are only billed on the first download. You can download as many more times as you want without incurring additional costs.

curl -s https://cloud.editide.com/api/presentations/$FILE_ID \
  -H "X-Api-Key: eid_your_key_here" \
  -o result.pptx

Merge presentations

POST /api/presentations/merge

Combines several uploaded decks into one, in the order given, and returns { "file_id": ..., "filename": ... } for the merged deck to download. All file_ids must belong to you.

Body:

Tools

List tools

GET /api/tools

Returns a JSON array of every editide tool with its parameter schema. This is the same catalog the agent draws from (see Tools).

Call a tool directly

POST /api/tools/{tool_name}

Runs a single tool deterministically, without the agent or an LLM key. The request body is that tool's parameters as JSON — find them with List tools or in the Tools section.

Attachments

You can upload attachments for the agent to reference in its tool calls. The agent has tools to read and import data from .xlsx, .pdf, .csv, and .json files. Similar to a presentation's file_id, you can upload an attachment to get an attachment_id to pass to the agent or reference in your direct tool calls.

Upload an attachment

POST /api/presentations/{file_id}/attachments

Send a multipart form with a single file field. Stores the file against the presentation session and returns { "attachment_id": ..., "filename": ... }. If the session already has a file by that name, the upload is renamed and the response carries the granted name — refer to the attachment by what came back, not what you sent.

ATTACHMENT_ID=$(curl -s https://cloud.editide.com/api/presentations/$FILE_ID/attachments \
  -H "X-Api-Key: eid_your_key_here" \
  -F "file=@q3.xlsx" | jq -r .attachment_id)

Pass that attachment_id to any tool that reads a data file — see Importing data and Files & references — or in attachment_ids on the /edit endpoint above. Over MCP, the equivalent upload is the upload_file tool.

Upload a standalone attachment

POST /api/attachments

A niche variant: upload a data file that isn't tied to any presentation. Send a multipart form with a single file field; returns { "attachment_id": ..., "filename": ... }. The id is scoped to your API key and works in direct tool calls (POST /api/tools/{tool_name} and the MCP tools) — for inspecting a file before a deck exists, e.g. get_excel_data_ranges to discover a workbook's sheets and ranges. It is not resolved by the /edit agent endpoint; for /edit, upload a per-presentation attachment instead.

Account

Check your key

GET /api/auth/whoami

Returns your identity, tier, and current-period usage without uploading a file or running a tool. Useful for verifying a key and reading your remaining slide quota.

curl -s https://cloud.editide.com/api/auth/whoami -H "X-Api-Key: eid_your_key_here"

The response includes tier, product, usage_cents_this_period, slides_delivered_this_period, and a tier_definition object with your plan's monthly_slides_included and monthly_budget_cents.

Supported file types

The primary file must be a .pptx. You can also attach secondary files to reference in your slide editing tasks.

Macro-enabled Office files (.pptm, .xlsm), .svg, and .json are not accepted.

Size limits

The maximum presentation upload size depends on your plan:

Attachment caps are fixed by type, independent of plan:

A session holds up to 25 attachments. At most 5 of those may be reference .pptx files.

Expiry

Files are deleted 8 hours after upload.

Per-minute limits

A single edit request is one Message, no matter how many tools the agent runs internally to satisfy it. You are not charged a rate-limit hit per internal tool call — only per request you make.

If you upload many files, spread them out instead of uploading all at once.

Limits are per account, not per key

All rate limits are scoped to your account, and every key you mint shares the same budget. Minting additional keys does not raise your limit — it splits it. If you need more headroom, upgrade your plan or contact us.

Concurrency

Separately from the per-minute limits, there is a ceiling on how many operations can be in flight at once per account — for example, simultaneous uploads. In practice you only reach it by firing many large operations in parallel. Keep a handful of concurrent requests in flight rather than dozens and you will not see it.

When you hit a limit

A throttled request returns:

HTTP/1.1 429 Too Many Requests
Content-Type: application/json
Retry-After: 60

{ "error": "Rate limit exceeded. Please slow down and retry shortly." }

Handle it by backing off and retrying. The Retry-After header tells you how many seconds to wait.

MCP clients

When you use editide through an MCP client, every tool call counts against the same Tools limit above, scoped to the same account. You rarely hit it interactively — the pace of an interactive session stays well under the limit. This will only be an issue with programmatic MCP usage.

Errors at a glance

All errors return JSON with an error field and a correlation_id for support.

What is MCP?

The Model Context Protocol (MCP) lets AI agents use external tools. The editide MCP server gives your agent tools to read, edit, and render PowerPoint files — from the AI app you already use.

Connect

One endpoint, and two ways to authenticate:

https://cloud.editide.com/mcp

Sign in with OAuth — the simplest path. Add the endpoint to any OAuth-capable MCP client with no credentials; the client opens your browser, you sign in with your editide account and approve, and you're connected. This works anywhere the standard MCP authorization flow does — Claude (web, desktop, and Claude Code), Cursor, ChatGPT, and others. It requires an active individual API subscription — sign up here.

Use an API key — for everything OAuth doesn't cover: team/org plans (not supported over OAuth yet), automation with no browser to sign in from, and per-integration credentials you can revoke individually. Send a key from the dashboard as an X-Api-Key header.

Either way, usage lands on your account identically — the same slide quotas, totals, and billing. Your MCP client also needs file access and network permissions to move decks in and out.

How It Works

Once connected, the agent works through a simple loop:

File transfer with signed URLs

editide runs in the cloud and never touches your filesystem, and a .pptx is too large to inline inside a tool call. So files don't travel through the agent — they move directly between your machine and editide over HTTPS, and only the compact file_id flows through MCP. Three tools set this up, each the same shape: you call the tool, it hands back a short-lived URL, and your client runs a one-line curl to move the bytes.

upload_file attaches a reference file (image, PDF, Excel, CSV, or a secondary .pptx) to an existing presentation's session; pass the returned attachment_id to tools like view_image_file, view_pdf, view_excel, or import_data_to_chart. For a secondary .pptx, pass its id as presentation_id to the reading tools to pull content from it. If the session already had a file by that name, the upload is renamed and the response carries the granted name. There is also merge_presentations, which combines several uploaded decks into one and returns the merged deck's file_id.

How the URL stays safe

Your API key authenticates the tool call that mints the URL — it never reaches the model or the curl command line. The signed URL itself is the only credential on the transfer, and it is deliberately weak on purpose:

• Single-use. Once a transfer completes, the URL is burned; replaying it fails.
• Short-lived. It expires about five minutes after it is minted (the response includes the exact expires_at).
• Tenant-bound. Identity and billing are baked into the URL when it's minted, so a URL can only ever touch files in the account that created it.

If a URL expires or a transfer fails, just call the tool again for a fresh one — there's no separate "retry" step. An interrupted upload or download leaves the URL live so the same command can be retried; only a clean success consumes it.

Uploaded files are deleted 8 hours after upload — see Files for limits and expiry, and Billing for how charges work.

Prerequisites

• An editide account with an active API subscription — sign up here.
• Claude Code in a Terminal CLI.

Connect with OAuth

From your terminal, navigate to the project folder and run:

claude mcp add --transport http editide https://cloud.editide.com/mcp

Then authenticate the connection:

OAuth requires an active individual API subscription.

On a Team plan? Use an API key

OAuth isn't available for Team plans yet, so an API key is the only option. Create one from the dashboard, then run:

claude mcp add --transport http editide https://cloud.editide.com/mcp --header "X-Api-Key: eid_your_api_key_here"

Manage the connection

Verify the server was added to your local config with:

claude mcp list

To remove, run:

claude mcp remove editide

See the Claude Code docs for more details.

Prerequisites

• An editide account with an active API subscription — sign up here.
• Claude Desktop, or Claude in the browser at claude.ai — connectors work the same in both, and one added connector appears in both.

Add the connector

The first three steps are required for either setup. Sign-in with OAuth needs an individual plan — on a team/org plan, complete the domain allowlist steps, then use the extension with an API key below instead.

1

Click on your user profile in the bottom left and then click on Settings.

2

Select Capabilities from the left sidebar, and scroll down to Domain allowlist.

3

Type in cloud.editide.com and click Add.

4

Select Connectors from the left sidebar, then click Add custom connector.

5

Name it editide and enter the server URL https://cloud.editide.com/mcp.

6

Click Add, then Connect — your browser opens to sign in with your editide account. Approve the connection.

7

Back in the Chat view, click the + in the bottom left of the input textbox and verify editide appears in your Connectors list.

You can now use editide to edit .pptx files you upload in Chat, or with local files accessible in Cowork and Code.

On a team plan? Install the extension with an API key

OAuth sign-in isn't available for team/org plans yet. The editide desktop extension carries an API key instead — it needs Claude Desktop (not the web-app) and an API key from the dashboard.

1

Select Extensions from the left sidebar.

2

If you don't have any extensions installed, you have to add an extension for the right setting to appear. Click Browse extensions and install any extension (pdf-viewer, Filesystem, etc.). If you already installed another extension, skip to step 4.

3

Close and go back to the Extensions panel where there should now be a Drag .MCPB or .DXT files here to install text below Advanced settings.

4

Download this editide.mcpb file.

5

Drag the file exactly into the area over Advanced settings or Drag .MCPB or .DXT files here to install.

If you drag outside the area, the file gets copied to your chat instead.

6

This confirmation pop-up will appear if you dragged into the correct area. Click Install and then confirm the new pop-up.

7

Enter your API key and click Save.

8

Click the toggle to Enable.

9

Go back to the Chat view, click the + in the bottom left of the input textbox, and verify editide appears in your Connectors list.

10

Refresh (ctrl + R) to make sure Claude establishes the connection.

When you are building your own agent and want it to read, edit, and render PowerPoint slides, you can attach the editide MCP server directly from the Anthropic Messages API or the OpenAI Responses API. Both providers act as the MCP client for you — they connect to the server, list its tools, and call them on the model's behalf.

Authentication

The MCP endpoint is https://cloud.editide.com/mcp. Authenticate with your editide API key from the dashboard — the same key works for the REST API and MCP. Each provider takes the key in a different field:

Anthropic

Attach editide through the MCP connector on the Messages API. The connector needs the beta header anthropic-beta: mcp-client-2025-11-20, an mcp_servers entry with the connection details, and an mcp_toolset in tools that references the server by name.

curl https://api.anthropic.com/v1/messages \
  -H "Content-Type: application/json" \
  -H "X-Api-Key: $ANTHROPIC_API_KEY" \
  -H "anthropic-version: 2023-06-01" \
  -H "anthropic-beta: mcp-client-2025-11-20" \
  -d '{
    "model": "claude-opus-5",
    "max_tokens": 4000,
    "messages": [
      {
        "role": "user",
        "content": "Add a closing Key Takeaways slide to presentation file_abc123."
      }
    ],
    "mcp_servers": [
      {
        "type": "url",
        "url": "https://cloud.editide.com/mcp",
        "name": "editide",
        "authorization_token": "eid_your_key_here"
      }
    ],
    "tools": [
      {
        "type": "mcp_toolset",
        "mcp_server_name": "editide"
      }
    ]
  }'

OpenAI

Attach editide with the mcp built-in tool type on the Responses API. Setting require_approval to never lets the model call editide tools without pausing for your approval — only do this for servers you trust.

curl https://api.openai.com/v1/responses \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer $OPENAI_API_KEY" \
  -d '{
    "model": "gpt-5",
    "tools": [
      {
        "type": "mcp",
        "server_label": "editide",
        "server_description": "Read, edit, and render PowerPoint (.pptx) presentations.",
        "server_url": "https://cloud.editide.com/mcp",
        "headers": {
          "X-Api-Key": "eid_your_key_here"
        },
        "require_approval": "never"
      }
    ],
    "input": "Add a closing Key Takeaways slide to presentation file_abc123."
  }'

Schemas

editide is built for AI agents first. Every tool ships a complete, machine-readable schema designed to be consumed by a model — GET /api/tools returns it unfiltered, exactly as an agent sees it.

curl https://cloud.editide.com/api/tools

These pages are the human-friendly version of that schema: organized, simplified, and written to read well. They won't match the raw output word-for-word, and if the two ever differ, the API is the source of truth.

Catalog

Editing

Reading

Slides

Themes, masters & layouts

Importing data

Files

Media

Calling over REST

Every tool is invoked with POST /api/tools/{tool_name} using the tool's input as the JSON body.

curl https://cloud.editide.com/api/tools/read_slide \
  -H "X-Api-Key: eid_your_key_here" \
  -H "Content-Type: application/json" \
  -d '{"presentation_id": "your_presentation_id", "slide_index": 1, "mode": "summary"}'

Over MCP you don't call this endpoint directly. Your agent invokes the tool through its MCP client with the same input shape.

Slide object

editide represents PowerPoint slides as a collection of elements. Each element carries an id, a position, and a size, plus content and styling specific to its type.

Element types

Call shape

Operations

edit_slide calls can modify existing elements or add new ones. Modifying an element requires passing its id (discovered after a read_slide call). When adding a new element, omit the id (it's automatically assigned).

Placeholders exist on layouts and masters only — a slide fills placeholders rather than defining them.

Beyond the element type operations, the slide object also accepts these fields:

The read–edit loop

Modifying an element requires passing its id, so the usual flow is read first, then edit.

Backgrounds

Every surface — slide, layout, and master — can carry a background. A slide with none inherits its layout's, and a layout with none inherits its master's, so setting the master's background restyles every slide that hasn't overridden it.

curl https://cloud.editide.com/api/tools/edit_slide \
  -H "X-Api-Key: eid_your_key_here" \
  -H "Content-Type: application/json" \
  -d '{
        "presentation_id": "your_presentation_id",
        "theme_name": "Office Theme",
        "target": "master",
        "slide": {
          "background": {"picture_uri": "https://example.com/texture.png"}
        }
      }'

Templates

When adding an element, you can clone an existing one instead of specifying every property. Set template_element_id (optionally with template_slide_index / template_presentation_id to point at another slide or deck) and the new element inherits its geometry, style, and formatting. This is the most reliable way to stay visually consistent with the deck's fonts, colors, and sizing.

The source can also live on a layout or master: address it with template_layout_name / template_layout_id / template_theme_name, or set template_target to walk up from template_slide_index — so a logo on a layout can be copied onto a slide, another layout, or a different deck.

Placeholder boxes (titles, subtitles, body text) can't be copied — the response explains why and suggests creating a new placeholder instead. A chart, table, or picture that merely fills a placeholder slot copies fine, arriving as a plain element.

Template fields apply only when adding: on an edit of an existing element they return an error rather than being silently ignored.

curl https://cloud.editide.com/api/tools/edit_slide \
  -H "X-Api-Key: eid_your_key_here" \
  -H "Content-Type: application/json" \
  -d '{
        "presentation_id": "your_presentation_id",
        "slide_index": 2,
        "slide": {
          "text_elements_to_add": [
            { "template_element_id": 5,
              "position": {"left": 40, "top": 320},
              "text_component": {
                "paragraph_list": [
                  { "runs": [ {"text": "Hello, world"} ] }
                ]
              } }
          ]
        }
      }'

position

Where an element sits and how it's oriented. All units measured in points, rotation in degrees.

size

color

Set scheme (theme color) or rgb (hex). For no fill, pass the plain string "transparent" instead of an object.

text_component

All text content — in a text box, a table cell, or a chart label — is a text_component: a list of paragraphs, each a list of runs.

paragraph

bullet

Bullet or numbering for a paragraph.

paragraph_style

Paragraph-level formatting. When adding bullets, set margin_left and indent together to create a hanging indent (e.g. 22.5 / -22.5) so the bullet and text don't collide.

text_layout

Insets and vertical alignment of text within its frame.

run

text_style

Run-level character formatting.

shape_style

Fill, border, effects, and line endings — shared by shapes, pictures, table data labels, and more.

gradient

A gradient fill — usable on shapes and on backgrounds.

effects

Visual effects on a shape, text frame, or picture. Each effect is its own object; set remove: true on one to clear it.

New & Improved

Works in more AI clients

• Tool definitions are now optimized per client, improving token cost, latency, and accuracy for OpenAI agents.
• Claude Code no longer receives cut-off tool definitions. Its MCP client truncates long tool descriptions; editide now detects it and serves a format that fits.
• Reading and editing now both use snake_case, improving agent tool call accuracy.

Editing

• Elements (logos, pictures, shapes, charts, tables) can now be copied from layouts and masters onto slides, onto other layouts, and between decks. Placeholders can't be copied — the response explains why and suggests creating a new one instead.
• Layouts and masters can now be read element-by-element, including their placeholders.
• Requesting a data-label position on a doughnut chart no longer produces a file PowerPoint has to repair. Doughnuts have no label-position control; the rest of the label applies and the response says so.
• Chart data with mismatched series keys is refused with the chart's actual series listed, instead of quietly creating stray new series. Series without names stay editable by index.
• Legend entry styling reads back complete — bolding entries no longer hid their color and size from later reads.
• Hyperlinks fixed in table cells (merged and unmerged) and grouped shapes.
• Combination charts (column/bar + line) now support full editing; markers are rejected on incompatible chart or series types instead of silently ignored.
• Adding a slide without specifying a layout now uses the deck's most-used layout instead of refusing the request.
• SVG color reading improved for no-fill SVGs and multicolor SVGs.
• Chart legend edits streamlined.

Clearer errors

• Billing states now come back as payment errors with a machine-readable reason — "account not finished setting up" reads differently from "monthly quota reached" — instead of a generic server error.
• An edit naming a presentation id that doesn't exist fails only that action, and the error lists the valid ids. Other work in the same request proceeds, and agent prompt guidance is streamlined.
• Color field rejections now supply the object shape in an error message and are stricter.
• Using "start from a template element" fields on an edit of an existing element now returns a clear error (they only apply when adding) instead of being silently ignored.

API

• OAuth sign-ins (MCP connectors) can now also call whoami — previously those endpoints accepted only API keys.
• The xhigh reasoning-effort setting now reaches OpenAI models correctly.

New and improved

Designs, layouts and masters

• Slide layouts and masters are now editable. A change made there follows every slide that uses them.
• Layouts can be added — as a copy of an existing one, or built from empty with title, content, picture, footer, date, and slide-number placeholders — and removed. New layouts appear in PowerPoint's layout gallery.
• A deck can carry a second design, with its own layouts, colors, and fonts.
• A slide can move to a different layout, keeping its content — the same behavior as PowerPoint's Layout menu.
• Layouts and designs can be renamed, and each layout reports which slides use it. Removing one still in use is refused, naming the slides.
• Footer, date, and slide number toggle per slide, per layout, or deck-wide. On a slide, the boxes copy in from its layout; dates and slide numbers are live fields that stay correct as slides move.
• Logos and icons can be placed on a layout or master, appearing on every slide that uses it.
• Layout placeholders can be moved, resized, and restyled, including the prompt text shown while empty.
• The deck's default text — font, size, and bullets for titles and body at each outline level — can be set in one place.
• Slide, layout, and master backgrounds can be set to a color, gradient, or picture, or cleared to follow the design again. Set on the master, a background image carries the whole design.

Shapes and pictures

• The full PowerPoint shape library — over 180 shapes: arrows, callouts, banners, flowchart symbols, stars, brackets, and the rest.
• Shape adjustment handles are settable: corner rounding, arrowhead size, star point depth, and so on per shape.
• Connectors attach to shapes and follow them when moved. The attachment side can be chosen, and connectors can be detached.
• Shadows, glows, reflections, and soft edges — with color, blur, distance, and direction controls — can be added and removed.
• Gradient fills, with control over colors, stop positions, and direction.
• Pictures already in a deck can be copied without supplying the file again.
• Shapes can be filled with a picture, cropping the image to the shape's outline.

Charts and tables

• Every PowerPoint chart type is recognized as itself — waterfall, funnel, treemap, sunburst, histogram, pareto, box-and-whisker, radar, area, surface, stock, scatter, bubble, map, pie-of-pie, and the 3-D forms.
• The newer chart types — waterfall, funnel, treemap, sunburst, histogram, pareto, box-and-whisker — take data edits: values, categories, and series.
• Radar, area, surface, stock, pie-of-pie, and 3-D charts can be moved, resized, retitled, and have their values changed. Scatter, bubble, and map charts can be moved and resized; their data isn't readable yet, and reads say so.
• The full surface — titles, legends, axes, data labels, series colors, type conversion, secondary axes, combo charts, and creation from scratch — covers column, bar, and line in all three forms (plain, stacked, 100% stacked), plus pie and doughnut. Anything beyond that is refused with a reason rather than silently dropped.
• Table cells merge and unmerge — across columns, down rows, or both.

Text

• Text can link to a web address, an email address, or another slide in the deck. Links can be removed.
• Highlight and strikethrough, in any color. Highlights follow the theme.
• Superscript and subscript, raised and sized the way PowerPoint does it, with autofit accounting for them.

Movement

• Animations can be added, retimed, reordered, and removed — PowerPoint's standard set of effects; other animations are left untouched.
• Slide transitions: any transition from PowerPoint's gallery, with direction, duration, and click or timed advance.

OAuth for MCP

• editide can connect to an AI assistant by signing in, with no API key to paste. Works with Claude Desktop, Claude Code, Claude Web, and ChatGPT Web; experience with other MCP clients may vary.

AI

• GPT 5.6 Luna, Terra, and Sol are available as model choices.
• Claude Opus upgraded from 4.8 to 5 at the same usage rates.

New and improved

• You can now edit a presentation's theme. Ask for new theme colors or fonts and every slide that follows the theme updates in one step.
• You can now start a brand-new presentation from scratch through the API or your MCP client (for example, Claude Desktop), with no file to upload first.
• You can move any or all slides onto another theme that already exists in your deck, keeping each slide's content and layout in place.
• Charts pasted in from other decks can now be told to follow your current theme's colors instead of keeping the colors they arrived with.
• Text that uses your theme's fonts now stays linked to the theme through AI edits, so changing the theme later restyles it the way you would expect.

Fixes

Charts

• Creating a new chart from an existing one as a template is now more reliable.
• Percentage data labels now behave correctly on every chart type.
• Converting a doughnut chart to a pie chart now handles unusual hole sizes correctly.
• Chart edits that PowerPoint accepts are no longer occasionally rejected as invalid.

Tables and formatting

• Table edits now land consistently on the row or column you asked for.
• Resizing a table that has a header row now works correctly.
• Replacing or clearing a cell's text now updates the whole cell.
• Table cells with a transparent fill now keep it, instead of being treated as having no fill.

Text and shapes

• Text set to shrink on overflow, or to resize its shape to fit, now matches PowerPoint's own layout much more closely.
• Bulleted lists now use more accurate spacing.

Sign-in and sessions

• The add-in now recovers on its own when your sign-in expires, instead of asking you to reload it.

AI

• Kimi K2.6 and Kimi K3 are now available. Two more models you can choose from when editing your presentation.
• Slimmed the tool definitions sent to the AI, so each edit uses noticeably fewer tokens with no change in quality.

Fixes

Charts

• Date values in chart-linked Excel sheets now roundtrip as real dates in ISO 8601 format (for example, 2026-01-09) instead of raw serial numbers. Conversion between text, formatted number, and formatted timeline axes is now more consistent.
• Dashed lines, arrowheads, and other line styles now work on chart data points and series.
• The default chart legend dock position now encodes correctly.
• Editing presentations generated by python-pptx is now more stable.

Tables and formatting

• Whole-table font changes now apply to empty cells.
• Bullet sizes can now be set in points or as a percentage.

External images

• Improved SVG handling.

Security

• Hardened add-in account key handling. No customer action is needed.

AI

• Reduced the system prompt size with no change in performance.
• Claude Sonnet 5 is now available. The Sonnet model now uses Claude Sonnet 5 at promotional rates.