Welcome
editide is the best way for AI agents to create and edit PowerPoint presentations.
We built a PowerPoint API from the ground up for AI, so your agents do more with fewer tokens.
Backed by a proprietary engine with zero Microsoft Office dependencies, editide runs in any environment.
Whether you work inside PowerPoint, in your favorite AI application, or directly in code, editide makes complex slide editing simple.
Email support@editide.com if you need any help.
Install the editide PowerPoint add-in
Step-by-step instructions to get started.
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.
Add-in installs may be restricted in your organization. If the steps below are unavailable, editide needs to be deployed by an administrator. Contact our sales team to set up an enterprise plan and roll it out across your organization.
Install for yourself (recommended)
The fastest way to get editide if you're setting it up for your own account.
In PowerPoint, go to the Home tab and click Add-ins. You can also click File and locate the Get Add-ins button.
Search for editide in the store, then click Add.
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.
This route requires a work or school account with admin rights. Personal accounts — including personal Gmail or consumer Microsoft accounts — can't deploy add-ins this way. If you don't have admin access, ask your IT administrator or contact our sales team.
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.
Select the users to add:
- Just me — your account only
- Entire organization — everyone in your tenant
- Specific users/groups — a subset of your organization
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.
Overview
Edit PowerPoint files programmatically with natural language or direct tool calls.
The REST API exposes the same engine that powers the add-in and MCP server.
The session lifecycle
Every file you upload opens a short-lived session, identified by a file_id.
Upload
A .pptx and get back a file_id that names the session.
Edit
Run the /edit agent with a natural-language instruction, or call tools directly for deterministic changes.
Download
The modified .pptx.
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.comKeys at a glance
| Key | Header | Needed for |
|---|---|---|
| editide API key | X-Api-Key | Every request |
| LLM key (BYOK) | X-Anthropic-Key, X-OpenAI-Key, or AWS Bedrock credentials | The /edit endpoint only |
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/toolsReturns a JSON array of all available PowerPoint tools with their parameter schemas.
Quick Start
Upload, edit, and download a deck in three calls.
Prerequisites
- An editide account with an active API subscription — sign up here.
- An API key from the dashboard.
Edit endpoint
Upload
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)Edit
Requires an LLM API key.
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"}'Download
curl -s https://cloud.editide.com/api/presentations/$FILE_ID \
-H "X-Api-Key: eid_your_key_here" \
-o result.pptxYou 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
Upload
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)edit_slide
No LLM API key needed.
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"} ] }
]
} }
]
}
}'Download
curl -s https://cloud.editide.com/api/presentations/$FILE_ID \
-H "X-Api-Key: eid_your_key_here" \
-o result.pptxAuthentication
Authenticate with API keys and bring-your-own LLM api key for the /edit endpoint.
editide API key
Required for every request. It identifies your account and tracks usage.
X-Api-Key: eid_your_key_hereGenerate 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: ... # optionalSending more than one shape, or a partial AWS triple, returns 400. AWS keys can be used to access both Claude and GPT models.
The LLM key is never stored — send it on every /edit call. It is used for the duration of the request and discarded.
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.
Keep keys server-side. The editide key authorizes billable edits, and an LLM key authorizes spend on your provider account — neither belongs in client-side code.
Billing
Outcome-based pricing — pay per slide delivered, not per requests or tokens.
You are billed per slide delivered: a slide whose content you created or changed, counted at the moment you retrieve it.
Delivery is the trigger — a slide only counts for billing once it leaves the service through a download or a merge.
Token usage is not billed by editide. Each /edit request returns its token usage for your reference, but the underlying LLM cost is charged to your own Anthropic, OpenAI, or AWS account.
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.
| Tool | Effect |
|---|---|
| edit_slide | Changes/adds text, shapes, tables, charts, or pictures on a slide |
| add_slide | Creates a new slide |
| copy_slide | Duplicates a slide, within a deck or across decks |
| import_data_to_chart | Creates or updates a chart from a spreadsheet file |
| import_data_to_table | Creates or updates a table from your data |
| insert_logo | Places a company logo on a slide |
| insert_icon | Places an icon on a slide |
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.
Endpoints
Presentations, attachments, and direct tool calls.
All endpoints live under https://cloud.editide.com and require the X-Api-Key header.
Request and response bodies are JSON in snake_case, except for the multipart uploads and the binary download noted below.
You can also visit the interactive Open API Explorer to test the endpoints directly.
Presentations
Upload a presentation
POST /api/presentationsSend 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)Edit a presentation
POST /api/presentations/{file_id}/editRun 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:
| Field | Type | Required | Description |
|---|---|---|---|
| instruction | string | yes | Natural-language description of the change. |
| model | string | no | One of haiku, sonnet, opus, gpt54, gpt55 (case-insensitive). Defaults to haiku. |
| attachment_ids | string[] | no | Attachments the agent may read for the edit — see Attachments. |
The model must match the LLM key you send: an Anthropic key pairs with haiku / sonnet / opus, an OpenAI key pairs with gpt54 / gpt55, and AWS Bedrock credentials work with any of the five.
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:
| Field | Type | Description |
|---|---|---|
| success | bool | Always true on a 200. |
| message | string | "Presentation edited successfully" when the deck changed, or "No changes were made". |
| file_id | string | The same id from your initial upload. |
| input_tokens | int | Fresh input tokens the agent read for the first time this turn (full price). Excludes prompt-cache reads and writes. |
| output_tokens | int | Tokens the agent produced on this turn. |
| cache_creation_tokens | int | Input tokens written into the prompt cache this turn. Anthropic charges a premium for these; always 0 for OpenAI models. |
| cache_read_tokens | int | Input tokens re-read from the prompt cache this turn, billed at a steep discount. On a warm conversation (repeated /edit calls on the same file_id) this is usually the largest bucket. |
The four token counts are provided solely so you can reconcile against your LLM provider's bill. editide bills per modified slide delivered, not per token (see Billing).
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.pptxMerge presentations
POST /api/presentations/mergeCombines 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:
| Field | Type | Required | Description |
|---|---|---|---|
| file_ids | string[] | yes | Presentations to merge, in output order. At least two are required. |
| output_filename | string | no | Name for the merged file. |
Tools
List tools
GET /api/toolsReturns 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}/attachmentsSend a multipart form with a single file field. Stores the file against the presentation session and returns { "attachment_id": ..., "filename": ... }.
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/attachmentsA 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/whoamiReturns 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.
Files
Supported file types and limits.
Supported file types
The primary file must be a .pptx. You can also attach secondary files to reference in your slide editing tasks.
| Type | Extensions | Use case |
|---|---|---|
| Images | .png, .jpg, .jpeg, .gif, .webp | Insert photos, reference visual layouts |
| Excel | .xlsx | Import data into charts and tables |
| Reference document content | ||
| CSV | .csv | Import tabular data |
| PowerPoint | .pptx | Copy slides or styles from a reference deck |
Macro-enabled Office files (.pptm, .xlsm), .svg, and .json are not accepted.
Size limits
The maximum presentation upload size depends on your plan:
| Plan | Max upload |
|---|---|
| Basic | 50 MB |
| Pro | 250 MB |
| Max / Enterprise | 500 MB |
Attachment caps are fixed by type, independent of plan:
| Attachment | Limit |
|---|---|
| Images | 10 MB |
| 13 MB or 100 pages | |
| Excel, CSV | 50 MB |
| Reference .pptx | 200 MB |
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.
Rate Limits
Understanding throttling and request frequency limits.
These limits are designed to prevent abuse and you likely do not need to worry about them under normal usage.
If you are encountering rate limits from your normal workflows, please contact us.
This page covers rate limits, for slide quota limits connected to your plan see Billing.
Per-minute limits
| Limit | Applies to | Default |
|---|---|---|
| Messages | Agent edits — POST /api/presentations/{file_id}/edit | 60 / min |
| Files | Uploads, downloads, merges, attachments | 60 / min |
| Tools | Direct tool calls — POST /api/tools/{tool_name}, and all MCP tool calls | 60 / min |
| Lifecycle | Cheap session and auth operations | 120 / min |
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.
These numbers are defaults and may change. Build retry logic against the 429 response and the Retry-After header rather than hardcoding a rate.
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.
Most 429s are short-term throttling and clear on their own. If the response message says a monthly limit was reached — for example, your operations allowance per billing period — that's a plan limit. Retrying won't help; upgrade or wait for your limits to reset.
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
| Status | Meaning | What to do |
|---|---|---|
| 429 | Too many requests this minute | Wait Retry-After seconds, then retry. |
| 402 | Monthly plan limit reached | Upgrade, or wait for the next billing period |
Errors
List of error status codes.
All errors return JSON with an error field and a correlation_id for support.
| Status | Meaning |
|---|---|
| 400 | Bad request — missing or invalid parameters, missing or mismatched LLM key on the /edit endpoint, or an unrecognized model |
| 401 | Unauthorized — missing or invalid API key, or key not authorized for this endpoint |
| 402 | Payment required — monthly plan limit reached (slides, operations, or downloads) |
| 404 | File not found or expired |
| 409 | Conflict — an edit is already in flight for this file_id; wait for it to finish before sending another |
| 413 | Payload too large — the upload exceeds your plan's size cap (see Files) |
| 429 | Too many requests — slow down and retry after the Retry-After window. A 429 that names a monthly limit means upgrade, not retry (see Rate Limits) |
| 500 | Server error — include the correlation_id when contacting support |
| 507 | Server temporarily at capacity — retry shortly |
A 402 and a 429 can both stem from limits, but they differ: 402 is your monthly plan allowance, while 429 is short-term per-minute throttling that usually clears on its own. See Rate Limits.
Overview
Run editide from your favorite AI apps like Claude Code, Claude Desktop, or Codex.
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.
Prerequisites
- An editide account with an active API subscription — sign up here.
- An API key from the dashboard.
- Any MCP compatible AI application like Claude Code, Claude Desktop, Codex, Cursor, etc.
- The application must have file access and network permissions.
How It Works
Once connected, the agent works through a simple loop:
Upload
The agent calls upload_presentation, which returns a file_id and a ready-to-run curl command. The file travels straight from your machine to editide over HTTPS; only the compact file_id flows through the agent.
Read
list_slides and read_slide let the agent inspect the deck. Reading is free, so it can study your layout and styling before changing anything.
Edit
edit_slide, add_slide, import_data_to_chart, and related tools modify the deck in place on editide's servers, referencing it by file_id.
See the result
get_slide_screenshot renders a slide back as an image, so the agent can check its own work and fix mistakes.
Download
download_presentation returns a one-time curl command that writes the finished .pptx back to your machine.
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.
| Tool | Returns | Move the bytes with |
|---|---|---|
| upload_presentation | file_id + upload_url | curl -T deck.pptx "<upload_url>" |
| download_presentation | filename + download_url | curl -o "<filename>" "<download_url>" |
| upload_file | attachment_id + upload_url | curl -T data.xlsx "<upload_url>" |
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 as file_path to tools like view_image_file, view_pdf, view_excel, reference_presentation, or import_data_to_chart.
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.
Because the key never lands on the curl command, nothing sensitive ends up in your shell history or the agent's context. This is what lets an MCP client move multi-megabyte decks without bloating the model's context or leaking credentials.
Uploaded files are deleted 8 hours after upload — see Files for limits and expiry, and Billing for how charges work.
Connect Claude Code to editide
Step-by-step instructions to set up the MCP connection.
Prerequisites
- An editide account with an active API subscription — sign up here.
- An API key from the dashboard.
- Claude Code in a Terminal CLI.
Claude Code
From your terminal, navigate to the project folder and run:
claude mcp add --transport http editide https://cloud.editide.com/mcp --header "X-Api-Key: eid_your_api_key_here"Verify the server was added to your local config with:
claude mcp listTo remove, run:
claude mcp remove editideSee the Claude Code docs for more details.
Connect Claude Desktop to editide
Step-by-step instructions to set up the MCP connection.
Prerequisites
- An editide account with an active API subscription — sign up here.
- An API key from the dashboard.
- Claude desktop (not the web-app).
Claude Desktop
Click on your user profile in the bottom left and then click on Settings.
Select Capabilities from the left sidebar, and scroll down to Domain allowlist.
Type in cloud.editide.com and click Add.
Select Extensions from the left sidebar.
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 7.
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.
Download this editide.mcpb file.
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.
This confirmation pop-up will appear if you dragged into the correct area. Click Install and then confirm the new pop-up.
Enter your API key and click Save.
Click the toggle to Enable.
Go back to the Chat view, click the + in the bottom left of the input textbox, and verify editide appears in your Connectors list.
Refresh (ctrl + R) to make sure Claude establishes the connection.
You can now use the editide MCP to edit .pptx files you upload in Chat, or with local files accessible in Cowork and Code.
Programmatic use
Connect to the editide MCP server with code.
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:
| Provider | How to pass the key |
|---|---|
| Anthropic Messages API | authorization_token: "eid_your_key_here" on the MCP server entry (sent as a Bearer token) |
| OpenAI Responses API | headers: { "X-Api-Key": "eid_your_key_here" } on the MCP tool |
The model has no access to your local filesystem. Upload your .pptx through the REST API first to get a file_id, then reference that id in your prompt. Download the finished deck once the model is done.
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-4-8",
"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."
}'Overview
Every editide capability is a tool: a function with a defined JSON input schema. Call one directly over REST, or let an agent invoke it over MCP.
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/toolsThese 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.
Over MCP, your agent reads these schemas automatically once the server is connected — you never wire up tools by hand.
Catalog
Editing
| edit_slide | Add, modify, and delete elements — text, shapes, pictures, charts, tables, and more. |
Reading
| list_slides | List every slide with its index and title. |
| read_slide | Read a slide's content as structured JSON. |
| read_element | Drill into a single element for its full properties and styling. |
| get_slide_screenshot | Render a slide to an image for visual context. |
| search_presentation | Find content across the deck with a regex. |
Slides & layouts
| add_slide | Add a new slide from a chosen layout. |
| move_slide | Reorder a slide within the deck. |
| copy_slide | Duplicate a slide, within a deck or across presentations. |
| delete_slides | Remove one or more slides. |
| list_slide_layouts | Discover the layouts and themes a deck offers. |
| read_layout | Inspect a layout's placeholder structure. |
Importing data
| import_data_to_chart | Pull cells from Excel or CSV straight into a chart. |
| import_data_to_table | Build or populate a table from JSON, CSV, or Excel. |
Files
| view_image_file | Load an uploaded image for visual analysis. |
| view_image_element | View a picture embedded in a slide. |
| view_pdf | Read a PDF's contents. |
| view_excel | View a spreadsheet as a table. |
| search_excel | Find cells matching a query in a spreadsheet. |
| get_excel_data_ranges | Map every data region in a spreadsheet. |
| screenshot_excel_range | Capture a formatted Excel range as an image. |
Media
| insert_logo | Find and place a company's logo by name. |
| insert_icon | Search an icon library and drop an icon onto a slide. |
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.
Reading slides
Inspect a presentation's structure and content.
list_slides
Lists every slide in the presentation with its 1-based index and title.
ID of the loaded presentation to target.
curl https://cloud.editide.com/api/tools/list_slides \
-H "X-Api-Key: eid_your_key_here" \
-H "Content-Type: application/json" \
-d '{
"presentation_id": "your_presentation_id"
}'read_slide
Reads a slide's content as structured JSON.
1-based index of the slide to read.
Detail level: full (default), summary, text, or content.
ID of the loaded presentation to target.
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": 3,
"mode": "summary"
}'read_element
Reads a single element by ID, returning its full properties, styling, and content.
1-based index of the slide containing the element.
ID of the element to read (from read_slide).
ID of the loaded presentation to target.
curl https://cloud.editide.com/api/tools/read_element \
-H "X-Api-Key: eid_your_key_here" \
-H "Content-Type: application/json" \
-d '{
"presentation_id": "your_presentation_id",
"slide_index": 3,
"element_id": 5
}'get_slide_screenshot
Renders a slide to an image, providing a visual ground truth alongside the structured data from read_slide.
1-based index of the slide to capture.
ID of the loaded presentation to target.
curl https://cloud.editide.com/api/tools/get_slide_screenshot \
-H "X-Api-Key: eid_your_key_here" \
-H "Content-Type: application/json" \
-d '{
"presentation_id": "your_presentation_id",
"slide_index": 3
}'search_presentation
Searches across slides for content matching a regex, returning a compact list of matches scoped by slide numbers, element types, and element IDs.
Regex to search for. Prefix with (?i) for case-insensitive matching.
Where to search: all (default), text, charts, or tables.
Slides to search, e.g. 1-10, 5,8,12, 3-5,10. Omit to search all.
ID of the loaded presentation to target.
curl https://cloud.editide.com/api/tools/search_presentation \
-H "X-Api-Key: eid_your_key_here" \
-H "Content-Type: application/json" \
-d '{
"presentation_id": "your_presentation_id",
"pattern": "(?i)revenue",
"scope": "text"
}'Slides & layouts
Add, move, copy, and delete slides. Discover the available layouts.
add_slide
Adds an empty slide with a given layout. Layout names vary by deck — call list_slide_layouts first, as common defaults aren't guaranteed to exist.
Exact layout name as it appears in the deck.
1-based insert position. Appends to the end if omitted.
Target a specific master when a layout name is shared across themes.
ID of the loaded presentation to target.
curl https://cloud.editide.com/api/tools/add_slide \
-H "X-Api-Key: eid_your_key_here" \
-H "Content-Type: application/json" \
-d '{
"presentation_id": "your_presentation_id",
"layout_name": "Title and Content"
}'move_slide
Moves a slide from one position to another within the presentation.
1-based index of the slide to move.
1-based destination position.
ID of the loaded presentation to target.
curl https://cloud.editide.com/api/tools/move_slide \
-H "X-Api-Key: eid_your_key_here" \
-H "Content-Type: application/json" \
-d '{
"presentation_id": "your_presentation_id",
"from_index": 5,
"to_index": 2
}'copy_slide
Creates a copy of a slide at a given position, within a deck or across presentations.
1-based index of the slide to copy.
1-based position for the copy. Defaults to (source_index + 1) if omitted.
Source deck. Defaults to presentation_id.
Destination layout to apply for cross-presentation copies.
Target a specific master in the destination deck.
Destination deck.
curl https://cloud.editide.com/api/tools/copy_slide \
-H "X-Api-Key: eid_your_key_here" \
-H "Content-Type: application/json" \
-d '{
"presentation_id": "your_presentation_id",
"source_index": 4,
"destination_index": 6
}'delete_slides
Deletes the specified slides from the presentation.
1-based indices of the slides to delete.
ID of the loaded presentation to target.
curl https://cloud.editide.com/api/tools/delete_slides \
-H "X-Api-Key: eid_your_key_here" \
-H "Content-Type: application/json" \
-d '{
"presentation_id": "your_presentation_id",
"slide_indices": [2, 5]
}'list_slide_layouts
Lists all layouts grouped by slide master (theme), each with its placeholder count. Call this to discover layout and theme names before add_slide, copy_slide, or read_layout.
ID of the loaded presentation to target.
curl https://cloud.editide.com/api/tools/list_slide_layouts \
-H "X-Api-Key: eid_your_key_here" \
-H "Content-Type: application/json" \
-d '{
"presentation_id": "your_presentation_id"
}'read_layout
Reads a layout's full placeholder structure (types, indices, positions, sizes) and the theme it belongs to. Provide either layout_name or slide_index.
1-based slide whose layout to read.
Exact layout name to read.
Disambiguate when multiple masters share a layout name.
ID of the loaded presentation to target.
curl https://cloud.editide.com/api/tools/read_layout \
-H "X-Api-Key: eid_your_key_here" \
-H "Content-Type: application/json" \
-d '{
"presentation_id": "your_presentation_id",
"layout_name": "Title and Content"
}'Importing data
Load data from Excel, CSV, JSON files straight into charts and tables.
These tools read from an attachment_id — upload the file first via Attachments. Inline data on import_data_to_table skips uploads entirely — see that tool.
import_data_to_chart
Pulls cell ranges from Excel or CSV into a chart, mapped to categories, series, and values. Omit element_id to create a new chart, set it to replace an existing chart's data, or combine it with the append parameters to add a single category or series.
An uploaded .xlsx or .csv.
1-based slide to place or find the chart on.
Defaults to the first sheet.
Existing chart to replace or append. Omit to create a new chart.
New charts only: clustered_column, stacked_column, clustered_bar, stacked_bar, percent_stacked_column, percent_stacked_bar, line, pie, doughnut. Defaults to line.
Cells holding the category labels — a single row or column.
Cells holding the series names, orthogonal to category_range.
Cells holding the values, totaling category × series count.
One cell with the new category/series label (append mode).
Values for the appended category or series.
category or series, to disambiguate a square append.
Per-series chart_type / secondary_axis overrides.
ID of the loaded presentation the chart lives in.
First upload the data file to get an attachment_id:
curl https://cloud.editide.com/api/presentations/your_presentation_id/attachments \
-H "X-Api-Key: eid_your_key_here" \
-F file=@q3.xlsx
# → { "attachment_id": "a1b2c3d4-...", "filename": "q3.xlsx" }Then pass that id as attachment_id:
curl https://cloud.editide.com/api/tools/import_data_to_chart \
-H "X-Api-Key: eid_your_key_here" \
-H "Content-Type: application/json" \
-d '{
"presentation_id": "your_presentation_id",
"attachment_id": "a1b2c3d4-...",
"slide_index": 4,
"chart_type": "clustered_column",
"category_range": "B2:D2",
"series_range": "A4,A5",
"values_range": "B4:D4,B5:D5"
}'import_data_to_table
Imports structured data into a table from inline JSON or a file. Create a new table, populate an existing one with element_id, or clone a styled template_element_id.
Use data to pass rows inline — no upload needed, which makes it the simplest path over REST. Use attachment_id instead to pull from an uploaded .json, .csv, or .xlsx; the two are mutually exclusive.
1-based slide containing or receiving the table.
Inline JSON to import — no upload needed. Mutually exclusive with attachment_id.
An uploaded .json, .csv, or .xlsx. Mutually exclusive with data.
Existing table to populate. Omit to create a new table.
Table to clone structure and style from.
Table width in points. Recommended; required for new tables.
Table height in points. Recommended; required for new tables.
Left edge of a new table, in points.
Top edge of a new table, in points.
Sheet to read from an .xlsx source. Defaults to the first.
Cell range to read from an .xlsx source.
Apply the table style's header band to the first row.
Apply alternating row banding.
ID of the loaded presentation to target.
A few finer layout controls (header-font maximization, variable row heights, template slide index) are omitted here — pull the full schema from GET /api/tools.
curl https://cloud.editide.com/api/tools/import_data_to_table \
-H "X-Api-Key: eid_your_key_here" \
-H "Content-Type: application/json" \
-d '{
"presentation_id": "your_presentation_id",
"slide_index": 4,
"target_width": 600,
"target_height": 200,
"first_row": true,
"data": "{\"columns\":[\"Region\",\"Revenue\"],\"rows\":[[\"EMEA\",\"4.2M\"],[\"APAC\",\"3.1M\"]]}"
}'Media
Insert company logos and icons onto a slide.
insert_logo
Finds a company's logo by name and inserts it onto a slide. Logos are sourced from Brandfetch.
Company name, e.g. Nike, Apple, Microsoft.
1-based slide to insert the logo on.
A position — { left, top, z_index, rotation, … } in points.
A size — { width, height } in points. Provide one dimension to keep aspect ratio.
Defaults to true.
ID of the loaded presentation to target.
curl https://cloud.editide.com/api/tools/insert_logo \
-H "X-Api-Key: eid_your_key_here" \
-H "Content-Type: application/json" \
-d '{
"presentation_id": "your_presentation_id",
"company": "Nike",
"slide_index": 2,
"position": { "left": 40, "top": 40 },
"size": { "width": 120 }
}'insert_icon
Searches an icon set by keyword and inserts the result onto a slide.
Search keyword, e.g. home, arrow right, checkmark.
1-based slide to insert the icon on.
filled or regular.
A color — { "scheme": "accent1" } or { "rgb": "#4472C4" }. Defaults to black.
A position — { left, top, z_index, rotation, … } in points.
A size — { width, height } in points. Provide one dimension to keep aspect ratio.
Defaults to true.
ID of the loaded presentation to target.
curl https://cloud.editide.com/api/tools/insert_icon \
-H "X-Api-Key: eid_your_key_here" \
-H "Content-Type: application/json" \
-d '{
"presentation_id": "your_presentation_id",
"query": "check",
"slide_index": 2,
"icon_set": "lucide",
"color": { "scheme": "accent1" }
}'Files
Inspect images, PDFs, and spreadsheets to inform slide edits.
Each tool takes the attachment_id of a file you've uploaded first (see Attachments).
view_image_file
Loads an uploaded image for visual analysis and returns a reference to use in edit_slide. Accepts .png, .jpg, .jpeg, .gif, .webp.
An uploaded image.
curl https://cloud.editide.com/api/tools/view_image_file \
-H "X-Api-Key: eid_your_key_here" \
-H "Content-Type: application/json" \
-d '{
"attachment_id": "your_attachment_id"
}'view_image_element
Views the image embedded in a picture element on a slide.
1-based slide containing the picture.
ID of the picture element.
ID of the loaded presentation to target.
curl https://cloud.editide.com/api/tools/view_image_element \
-H "X-Api-Key: eid_your_key_here" \
-H "Content-Type: application/json" \
-d '{
"slide_index": 3,
"element_id": 5,
"presentation_id": "your_presentation_id"
}'view_pdf
Read a PDF's content.
An uploaded .pdf.
Page selection, e.g. 1-5 or 1,3,5. Omit to read all pages.
curl https://cloud.editide.com/api/tools/view_pdf \
-H "X-Api-Key: eid_your_key_here" \
-H "Content-Type: application/json" \
-d '{
"attachment_id": "your_attachment_id",
"pages": "1-5"
}'view_excel
Reads an .xlsx or .csv file as a markdown table.
An uploaded .xlsx or .csv.
Defaults to the first sheet.
Cell range to read, e.g. C4:F20. Auto-detects if omitted.
Maximum data rows to return (default 15).
1-based offset into the data rows to start from.
curl https://cloud.editide.com/api/tools/view_excel \
-H "X-Api-Key: eid_your_key_here" \
-H "Content-Type: application/json" \
-d '{
"attachment_id": "your_attachment_id",
"sheet_name": "Q3",
"range": "C4:F20"
}'search_excel
Searches an .xlsx or .csv file for cells matching a query, returning matches with their sheet, cell reference, and context.
The uploaded .xlsx or .csv to search.
Text to search for. Substring match by default.
Limit the search to one sheet.
Maximum matches to return (default 20).
Interpret the query as a regular expression.
Require the whole cell to equal the query.
Bounding range to limit the search area.
curl https://cloud.editide.com/api/tools/search_excel \
-H "X-Api-Key: eid_your_key_here" \
-H "Content-Type: application/json" \
-d '{
"attachment_id": "your_attachment_id",
"query": "Revenue"
}'get_excel_data_ranges
Maps an .xlsx or .csv file by detecting every data region on every sheet.
The uploaded .xlsx or .csv to map.
Limit the map to one sheet.
curl https://cloud.editide.com/api/tools/get_excel_data_ranges \
-H "X-Api-Key: eid_your_key_here" \
-H "Content-Type: application/json" \
-d '{
"attachment_id": "your_attachment_id"
}'screenshot_excel_range
Captures a screenshot of an Excel range as an image, returning a reference to use as a picture uri in edit_slide. Useful for exporting financial tables as rendered in Excel.
An uploaded .xlsx.
Cell range to capture, e.g. A1:H20.
Defaults to the first sheet.
Recolor numeric cells to black before capture.
curl https://cloud.editide.com/api/tools/screenshot_excel_range \
-H "X-Api-Key: eid_your_key_here" \
-H "Content-Type: application/json" \
-d '{
"attachment_id": "your_attachment_id",
"range": "A1:H20"
}'Overview
Add, modify, and delete elements on a slide.
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
| Text | Shapes containing text. |
| Shape | Rectangles, ellipses, lines, connectors, etc. No text content. |
| Picture | Images including SVG. |
| Chart | Native charts with editable data in an embedded Excel workbook. |
| Table | Native table containing cells with text. |
| Group | Contains other elements and moves them together. |
Call shape
| Parameter | Type | Description |
|---|---|---|
| presentation_id | string | ID of the loaded presentation to target. |
| slide_index | integer | 1-based index of the slide to edit. |
| slide | object | The slide object's contents — the element operations to apply, grouped by type. |
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).
| Element type | Modify | Add |
|---|---|---|
| Text | text_elements | text_elements_to_add |
| Shape | shape_elements | shape_elements_to_add |
| Picture | picture_elements | picture_elements_to_add |
| Chart | chart_elements | chart_elements_to_add |
| Table | table_elements | table_elements_to_add |
| Group | group_elements | — |
Beyond the element type operations, the slide object also accepts these fields:
| Field | Type | Description |
|---|---|---|
| elements_to_delete | integer[] | IDs of any elements to delete, of any type. |
| notes | object | Change the speaker notes text content. |
| clear_notes | boolean | Wipe all speaker notes. Wins over notes if both are set. |
Groups are modify-only: pass a group's id with a new position or size to move or resize it and everything inside it together. You can't create, ungroup, or change the membership of a group with edit_slide — operate on the child elements individually instead.
The read–edit loop
Modifying an element requires passing its id, so the usual flow is read first, then edit.
Read the slide. Call read_slide to get each element's id and current properties.
Build the operation. Put only the fields you want to change inside the matching elements list — omitted fields are left untouched.
Call edit_slide. Pass presentation_id, slide_index, and the slide object.
Elements with is_locked = true come from the layout or master. They can't be modified or deleted with this tool.
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.
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"} ] }
]
} }
]
}
}'Text elements
Add and modify text boxes.
Fields
Required when modifying. Omit when adding.
A position.
A size.
The text content: paragraphs and runs.
Frame geometry: rectangle, round_rectangle, ellipse, triangle, line, connector.
A shape_style for fill and border.
How frame and text fit: none (overflow), shrink (shrink text to fit), resize (grow frame to fit).
Wrap text within the frame width, or let it run on.
Clone an existing text element instead of styling from scratch.
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": 3,
"slide": {
"text_elements_to_add": [
{ "position": {"left": 48, "top": 90},
"size": {"width": 560, "height": 200},
"autofit": "resize",
"text_component": {
"paragraph_list": [
{ "style": {"alignment": "left" },
"runs": [
{ "text": "Revenue up 18% year over year",
"text_style": {"is_bold": true} }
] }
]
} }
]
}
}'Shapes
Add and modify shapes — rectangles, ellipses, triangles, lines, and connectors.
Fields
Required when modifying. Omit when adding.
A position.
A size.
rectangle, round_rectangle, ellipse, triangle, line, connector.
A shape_style — fill, border, and arrow ends.
Clone an existing shape to inherit its geometry and style.
Lines and connectors draw top-left to bottom-right by default. Set head_arrow / tail_arrow in shape_style for arrowheads, and flip_horizontal / flip_vertical in position to point them another way.
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": 4,
"slide": {
"shape_elements_to_add": [
{ "shape_type": "round_rectangle",
"position": {"left": 60, "top": 120},
"size": {"width": 220, "height": 90},
"shape_style": {"fill": {"scheme": "accent1"},
"border_color": "transparent"} }
]
}
}'Pictures
Add or modify pictures, including SVG images.
Fields
Required when modifying. Omit when adding.
Image source — an http/https URL or a local file path.
A position.
A size. Provide one dimension to keep aspect ratio.
Defaults to true. Set false only to stretch to exact dimensions.
A shape_style. For SVG-backed pictures, fill recolors and border redraws the stroke; for raster images they set a background and outline.
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": 5,
"slide": {
"picture_elements_to_add": [
{ "uri": "https://example.com/chart.png",
"position": {"left": 80, "top": 100},
"size": {"width": 480} }
]
}
}'Charts
Add and modify charts — series and data, axes, legends, titles, and data labels.
Top-level fields
Required when modifying. Omit when adding.
A position.
A size.
The series — see below.
New or changed values, keyed by composite category → series keys.
Title text component and placement.
Legend placement, styling, and per-entry overrides.
Category axes.
Value axes.
Clone an existing chart, including its data and style.
Chart type (bar, line, pie, etc.) is set on each series, not on the chart. A single chart can mix types to form a combo chart.
Composite keys in chart_data
Names alone aren't unique, so categories and series are addressed by a composite index:name key. chart_data is a map of category key → series key → value:
{ "0:Q1 2026": { "0:Revenue": 150000, "1:Expenses": 120000 },
"1:Q2 2026": { "0:Revenue": 175000, "1:Expenses": 125000 } }Categories
Rename categories by zero-based index.
Composite keys (index:name) of categories to drop.
Full category list in the desired order.
Wipe all categories (needs replacement chart_data).
Series
Each series controls its own type, data points, markers, and data labels.
Identify the series. Use index when names repeat.
Rename the series.
Series names to drop.
Wipe all series (needs replacement chart_data).
clustered_column, stacked_column, clustered_bar, stacked_bar, percent_stacked_column, percent_stacked_bar, line, pie, doughnut.
Plot this series against the secondary axis.
Per-point fill and border.
Marker shape, size, and styling.
What labels show and how they're positioned.
Pie/doughnut slice offset from center.
Data labels
A series carries one default_data_label (applied to every point) plus data_labels entries that override individual points by index.
What the label displays — value, category name, series name, or percent of total (pie).
Colored swatch matching the series color next to the label.
Leader lines from moved labels back to their points (default_data_label only).
Value format string (e.g. #,##0).
Separator between label components.
Per-label placement: outside_end, center, inside_end, inside_base, left, right, above, below, best_fit.
Offset from the docked position.
Clears the offset.
Custom label text — breaks dynamic field linkage. Per-label entries only.
Chart title
Title text and styling.
Fill and border for the title box.
Let the title overlap the plot area instead of reserving space above it.
edge (snap to an edge) or factor (offset from center/default).
Position (interpreted per mode).
Returns to the default centered placement.
Chart legend
bottom, top, left, right, top_right. Setting dock alone clears any manual layout.
Let the legend overlap the plot area instead of shrinking it.
Default text formatting for all entries.
Legend box fill and border.
edge (fraction of chart) or factor (offset from dock).
Manual position (interpreted per mode).
Manual size as a fraction of chart width/height.
Snap back to automatic layout.
Snap back to automatic sizing.
Per-entry overrides by index: delete to hide an entry, text_style to format it.
Axes
Each of the four axis slots (primary_category_axis, secondary_category_axis, primary_value_axis, secondary_value_axis) is an axis object.
Scale bounds and tick interval. Setting a value disables its auto_* flag.
Compute scale automatically (same algorithm as PowerPoint).
Gridline styling.
Where labels sit.
How values are formatted.
Axis title text and placement.
Where this axis crosses the other.
Hide the axis.
Bar, pie, and doughnut knobs
Bar/column gap as a percent of bar width (0–500).
Bar/column overlap percent (−100 to 100).
Doughnut hole as a percent of diameter (0–90).
Starting angle for pie/doughnut slices.
Charts expose far more — every data-label component, leader lines, marker geometry, axis time units, legend layout modes. Pull the full schema from GET /api/tools; these pages cover the fields you reach for most.
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": 6,
"slide": {
"chart_elements_to_add": [
{
"position": {"left": 60, "top": 120},
"size": {"width": 560, "height": 320},
"series_list": [
{
"name": "Revenue",
"chart_type": "clustered_column",
"default_data_point": {"fill": {"scheme": "accent1"}},
"default_data_label": {
"show_value": true,
"number_format": "$#,##0",
"dock": "outside_end"
}
},
{
"name": "Margin %",
"chart_type": "line",
"uses_secondary_axis": true,
"default_data_point": {"border": {"color": {"scheme": "accent4"}, "weight": 2.25}},
"default_marker": {"marker_type": "circle", "size": 7},
"default_data_label": {
"show_value": true,
"number_format": "0%",
"dock": "above",
"default_text_style_for_all_runs": {"font_color": {"scheme": "lt1"}, "is_bold": true}
}
}
],
"chart_data": {
"0:Q1": {"0:Revenue": 150000, "1:Margin %": 0.32},
"1:Q2": {"0:Revenue": 175000, "1:Margin %": 0.35},
"2:Q3": {"0:Revenue": 162000, "1:Margin %": 0.33},
"3:Q4": {"0:Revenue": 198000, "1:Margin %": 0.38}
},
"chart_title": {
"text_component": {
"paragraph_list": [
{"runs": [
{"text": "FY2026 Revenue & Margin",
"text_style": {"is_bold": true}}
]}
]
},
"overlay": false
},
"chart_legend": {
"dock": "bottom"
},
"primary_value_axis": {
"min": 0,
"max": 250000,
"units": 50000,
"number_format": "$#,##0",
"remove_major_gridlines": true
},
"secondary_value_axis": {
"min": 0,
"max": 0.8,
"number_format": "0%"
}
}
]
}
}'Tables
Add and modify native PowerPoint tables — rows, columns, cells, and the styles that cascade across them.
To fill a table from a spreadsheet or JSON rather than building cells by hand, use import_data_to_table.
Top-level fields
Required when modifying. Omit when adding.
A position.
A size.
Column and row definitions.
New columns / rows, placed by final index.
Zero-based indices to remove (delete runs before add).
Table-level cell style — the top of the cascade.
Table-style toggles: first_row, first_column, last_row, last_column, band_row, band_column.
Clone an existing table's structure and style.
Columns
Zero-based column position.
Column width in points. When adding, defaults to the adjacent column's width.
Style for every cell in the column. Overrides table defaults; overridden by row and cell.
Largest font that fits the column without changing row heights.
columns_to_add only: append grows the table (default); insert keeps the table's size and resizes existing columns to make room.
Rows
Zero-based row position. Row 0 is the header when first_row is on.
Row height in points. When adding, defaults to the preceding row's height.
Style for every cell in the row. Overrides table and column defaults; overridden by cell.
Per-row override of the table-level lazy / lock / auto_fit.
Largest font that fits the row without changing its height.
Force this row's height, fitting fonts to match.
Shrink just this row to its own content minimum, independent of other rows.
rows_to_add only: append grows the table (default); insert keeps the table's size and resizes existing rows.
The row's cells.
Cells
Zero-based cell position within the row, left to right.
Shorthand: plain text as a single run. Replaces only text content — existing run formatting is preserved. Ignored when text_component is set.
Full text component — use when you need explicit run styling, multiple paragraphs, or runs.
Cell borders and fill.
Largest font that fits this cell without changing the row height. Overrides table, column, and row target_font_size.
Shared Cell style
A default_cell_style is formatting shared by every cell at its level.
Font, size, bold, color.
Alignment, indents, spacing.
Vertical alignment and insets.
Cell fill — a color.
Cell edges — see Borders below.
Styling resolves Table → Column → Row → Cell, most specific wins. A cell's own style carries only fill and borders — per-cell text styling lives on the runs inside its text_component, not here.
Borders
A borders object sets a cell's edges, on any default_cell_style or a cell's style.
Shorthand — one border applied to all four edges.
Per-edge border; overrides all_borders.
Border
Each edge is a single border object.
A color.
Border width in points.
Dash pattern: solid, dot, dash, dash_dot, long_dash, … (omit for solid).
Sizing & side effects
Changing fonts or dimensions can resize rows; these fields control how.
lazy (PowerPoint decides), lock (freeze what you didn't change), auto_fit (adjust to match — default). Set this whenever you change content or dimensions.
With auto_fit: cell, row_or_col, or table uniformity.
Largest font that fits without resizing; settable at table, column, row, or cell level.
Force overall table height, fitting fonts and rows to match.
Set every row to the tallest row's content height.
A {start_index, end_index} range (inclusive) to equalize — rows to the tallest content height, columns to equal width.
Include the header row in table-level sizing operations.
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": 4,
"slide": {
"table_elements_to_add": [
{
"position": {"left": 100, "top": 100},
"size": {"width": 760, "height": 340},
"properties": {"first_row": true},
"default_cell_style": {
"text_layout": {"vertical_alignment": "Middle"},
"borders": {
"bottom": {"color": {"scheme": "accent3"}, "weight": 1}
}
},
"rows": [
{
"index": 0,
"default_cell_style": {
"text_style": {"is_bold": true},
"text_layout": {"vertical_alignment": "Bottom"}
},
"cells": [
{"index": 0, "text": "Name"},
{"index": 1, "text": "Value"},
{"index": 2, "text": "Status"}
]
},
{
"index": 1,
"cells": [
{"index": 0, "text": "Alpha"},
{"index": 1, "text": "42"},
{"index": 2, "text": "Active"}
]
},
{
"index": 2,
"cells": [
{"index": 0, "text": "Beta"},
{"index": 1, "text": "87"},
{"index": 2, "text": "Pending"}
]
},
{
"index": 3,
"cells": [
{"index": 0, "text": "Gamma"},
{"index": 1, "text": "156"},
{"index": 2, "text": "Complete"}
]
}
]
}
]
}
}'Text-box grids
Build "boxy tables" — grids assembled from individual text elements rather than a native PowerPoint table.
A text-box grid is a layout of independent text boxes arranged in rows and columns. They're a common alternative to native tables when you want full per-cell control over position and styling. Add them via text_box_grids_to_add — there's no modify list, because the grid is created as a collection of individual text elements. To change a grid afterward, edit the text elements by their own id through text_elements.
Top-level fields
A position.
A size. Required in fixed mode; computed in auto mode.
How grid dimensions are derived.
Grid-level cell style — the top of the cascade.
Column definitions: index, width, default_style.
Row definitions: index, height, default_style, and cells.
Sizing
auto (size grid to content; row/column sizes are fixed values) or fixed (explicit grid bounds; row/column sizes are proportional star values).
Optional caps in auto mode; content scales down to fit.
Column & row sizing
The magnitude: an absolute size in fixed, a proportional weight in star.
fixed (absolute points) or star (proportional share of the grid bounds).
Match the type to the mode: use fixed lengths in auto grids (the grid sizes to content), and star lengths in fixed grids (rows/columns divide the explicit bounds proportionally).
Cells
Zero-based cell position within the row, left to right.
Shorthand: plain text as a single run.
A list of paragraphs for rich text — use instead of text when you need runs, multiple paragraphs, or per-run styling.
A text_box_grid_cell_style for this cell — the most specific level of the cascade.
Cell style
A text_style — font, size, weight, color.
A text_layout — insets, anchoring, wrapping.
A paragraph_style — alignment, spacing.
A color for the cell background.
A single { color, weight } applied to the cell — simpler than table borders (no per-edge sides, no dash patterns).
Cell styles cascade Grid → Column → Row → Cell, most specific wins. Set default_style at the broadest level that works rather than styling each cell.
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": 8,
"slide": {
"text_box_grids_to_add": [
{ "position": {"left": 60, "top": 120},
"size": {"width": 480, "height": 200},
"sizing": {"width_mode": "fixed", "height_mode": "fixed"},
"default_style": {"text_style": {"font_size": 12},
"text_layout": {"vertical_alignment": "middle"},
"fill": {"scheme": "bg1"}},
"columns": [
{ "index": 0, "width": {"value": 2, "type": "star"} },
{ "index": 1, "width": {"value": 1, "type": "star"},
"default_style": {"paragraph_style": {"alignment": "right"}} }
],
"rows": [
{ "index": 0, "height": {"value": 1, "type": "star"},
"default_style": {"text_style": {"is_bold": true, "color": {"scheme": "bg1"}},
"fill": {"scheme": "accent1"},
"border": {"weight": 1.5, "color": {"scheme": "accent1"}}},
"cells": [ {"index": 0, "text": "Metric"},
{"index": 1, "text": "Value"} ] },
{ "index": 1, "height": {"value": 1, "type": "star"},
"cells": [ {"index": 0, "text": "Gross margin"},
{"index": 1, "text": "32%"} ] },
{ "index": 2, "height": {"value": 1, "type": "star"},
"cells": [
{"index": 0, "paragraphs": [{"runs": [{"text": "Net margin "},
{"text": "(YoY)", "text_style": {"is_italic": true}}]}]},
{"index": 1, "text": "18%",
"style": {"text_style": {"is_bold": true, "color": {"scheme": "accent1"}}}} ] }
] }
]
}
}'Data types
The building blocks elements share.
These objects appear throughout edit_slide. A picture, a shape, and a table cell all describe their fill with the same color; every text element, table cell, and chart label builds its content from the same text_component.
position
Where an element sits and how it's oriented. All units measured in points, rotation in degrees.
Left edge of the element, in points.
Top edge of the element, in points.
Stacking order — 0 is back, higher is front.
Clockwise angle, 0–360.
Mirror left-to-right. For lines/connectors, changes arrow direction.
Mirror top-to-bottom. For lines/connectors, changes arrow direction.
size
In points.
In points.
color
Set scheme (theme color) or rgb (hex). For no fill, pass the plain string "transparent" instead of an object.
Theme color: dk1, dk2, lt1, lt2, tx1, tx2, bg1, bg2, accent1–accent6, hlink, fol_hlink.
Hex string, e.g. #4472C4.
Multiply brightness.
Add brightness.
Multiply saturation.
Add saturation.
Darken toward black.
Lighten toward white.
Opacity — 0 transparent, 100 opaque.
Bake a scheme color to its resolved hex, breaking theme linkage.
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.
The paragraphs.
A text_layout for the frame.
Zero-based indices of paragraphs to remove.
paragraph
Zero-based position of the paragraph.
The runs of text.
A paragraph_style.
Outline level for nested bullets.
A bullet.
Zero-based indices of runs to remove.
bullet
Bullet or numbering for a paragraph.
none, character, numbered, picture.
The glyph (e.g. •, –, ►) — only when type is character.
Numbering style — only when type is numbered.
First number — only when type is numbered.
Image reference — only when type is picture.
A color.
Bullet font.
Bullet size — points, or a percentage of the paragraph font when font_size_is_percentage is set (e.g. 100 = same size as the paragraph font size).
Treat font_size as a percentage of the paragraph font, where 100 means 100%.
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.
left, center, right, justify.
Multiplier — 1.0 single, 1.5, 2.0 double.
Space above the paragraph, in points.
Space below the paragraph, in points.
Left margin in points.
Hanging indent in points (negative pulls the bullet back).
text_layout
Insets and vertical alignment of text within its frame.
Internal padding in points.
top, middle, bottom.
run
Zero-based position of the run within the paragraph.
The run's text. Don't edit field runs like [VALUE] in data labels — it breaks their data linkage.
A text_style.
text_style
Run-level character formatting.
Font name.
Points.
A color.
Bold.
Italic.
Underline.
shape_style
Fill, border, and line endings — shared by shapes, pictures, table data labels, and more.
A color, or "transparent".
A color, or "transparent".
Points. 0 means no border.
solid, dot, dash, dash_dot, long_dash, …
flat, round, square.
round, bevel, miter.
Line/connector start: none, triangle, stealth, diamond, oval, arrow.
Line/connector end: none, triangle, stealth, diamond, oval, arrow.