Generate presentations with the API

PRESENTON API GUIDE

From one prompt to a polished presentation.

Start simple, then add files, design systems, structured slide data, agents, and background jobs using the deployment that fits your stack.

Cloud

Managed API · v3

Open Source

Self-hosted API · v1

Cloud
Open Source

These workflows use the Presenton Cloud API v3. Keep uploaded file values, template IDs, task IDs, and presentation IDs in the same Cloud account that created them.

Before you begin

Create a Cloud API key and send it as a bearer token with every request:

Authorization: Bearer YOUR_API_KEY

The response from a completed generation request contains:

{
  "presentation_id": "8f29a2e7-4f26-48d2-9d1d-9b0716909a6d",
  "path": "https://example.com/generated-presentation.pptx",
  "edit_path": "https://presenton.ai/presentation?id=8f29a2e7-4f26-48d2-9d1d-9b0716909a6d",
  "credits_consumed": 7
}

Use path for the generated file and edit_path when a person should review or refine the deck in Presenton.

1. Generate a presentation directly

Use direct generation when the prompt contains all the context Presenton needs. The synchronous endpoint keeps the connection open until generation finishes.

Four labeled steps showing a prompt sent to the Presenton API, generated, and returned as an editable presentation

Direct generation turns one prompt into an editable presentation and exported PPTX.

Send only the presentation content. Presenton uses the endpoint defaults for the slide count, language, design, title slide, and PPTX export.

curl --request POST \
  --url https://api.presenton.ai/api/v3/presentation/generate \
  --header "Authorization: Bearer YOUR_API_KEY" \
  --header "Content-Type: application/json" \
  --data '{
    "content": "Create a seven-slide customer-facing launch deck for Atlas Analytics. The audience is enterprise operations leaders. Cover the problem, new capabilities, proof points, rollout plan, security, and next steps. Use concise executive language and do not invent customer metrics."
  }'

Read the exact request and response schemas in Generate a presentation synchronously.

2. Generate from uploaded files

Use this workflow when the presentation must be grounded in reports, spreadsheets, PDFs, or other supported source files.

Five labeled steps showing source files uploaded, saved as file values, and used to generate a grounded presentation

Upload the sources once, then pass their returned file values into generation.

Upload the files

curl --request POST \
  --url https://api.presenton.ai/api/v3/files/upload \
  --header "Authorization: Bearer YOUR_API_KEY" \
  --form "files=@./quarterly-report.pdf" \
  --form "files=@./customer-metrics.xlsx"

The upload response is an array of file values:

[
  "uploads/quarterly-report-a19f.pdf",
  "uploads/customer-metrics-52b1.xlsx"
]

Generate from those values

Pass the array back in files. Use content to tell Presenton what the deck should accomplish with the source material.

curl --request POST \
  --url https://api.presenton.ai/api/v3/presentation/generate \
  --header "Authorization: Bearer YOUR_API_KEY" \
  --header "Content-Type: application/json" \
  --data '{
    "files": [
      "uploads/quarterly-report-a19f.pdf",
      "uploads/customer-metrics-52b1.xlsx"
    ],
    "content": "Create an executive quarterly review. Prioritize revenue, retention, customer risks, and next-quarter actions. Preserve every reported figure exactly."
  }'

See Upload source files and Generate a presentation synchronously.

3. Generate in Standard or Smart mode

Choose one design mode for each request. Send standard_template for Standard mode or smart_design for Smart mode. Do not send both fields together.

Standard and Smart are alternative design paths for the same generation request.

Standard mode

Standard mode uses a template with reusable, schema-backed layouts.

curl --request GET \
  --url https://api.presenton.ai/api/v3/standard-template/all \
  --header "Authorization: Bearer YOUR_API_KEY"

Choose an id from the response and generate:

curl --request POST \
  --url https://api.presenton.ai/api/v3/presentation/generate \
  --header "Authorization: Bearer YOUR_API_KEY" \
  --header "Content-Type: application/json" \
  --data '{
    "content": "Create a six-slide partner enablement presentation for a new analytics product.",
    "standard_template": "neo-modern"
  }'

Smart mode

Smart mode uses a Smart Design that composes each slide around its content.

curl --request GET \
  --url https://api.presenton.ai/api/v3/smart-design/all \
  --header "Authorization: Bearer YOUR_API_KEY"

Choose an id from the response and generate:

curl --request POST \
  --url https://api.presenton.ai/api/v3/presentation/generate \
  --header "Authorization: Bearer YOUR_API_KEY" \
  --header "Content-Type: application/json" \
  --data '{
    "content": "Create a six-slide partner enablement presentation for a new analytics product.",
    "smart_design": "REPLACE_WITH_SMART_DESIGN_ID"
  }'

See List Standard templates and List Smart Designs.

4. Import a PPTX template and generate

Importing a PPTX template happens in Presenton Template Studio. Cloud v3 does not expose a public PPTX-template import endpoint. After the template is saved, the generation workflow uses the public API.

Five labeled steps showing a filled PPTX imported in Template Studio, saved as a template, and used through the API

Template Studio converts a branded PPTX into a reusable template for API generation.

Import the filled PPTX in Template Studio, resolve missing fonts, review the detected layouts, and save the template. Follow Create a template from PPTX.
List the account’s Standard templates and find the saved template ID.
Send that ID as standard_template in the synchronous generation request.

curl --request GET \
  --url https://api.presenton.ai/api/v3/standard-template/all \
  --header "Authorization: Bearer YOUR_API_KEY"

curl --request POST \
  --url https://api.presenton.ai/api/v3/presentation/generate \
  --header "Authorization: Bearer YOUR_API_KEY" \
  --header "Content-Type: application/json" \
  --data '{
    "content": "Create a seven-slide annual strategy presentation for the leadership offsite.",
    "standard_template": "REPLACE_WITH_IMPORTED_TEMPLATE_ID"
  }'

5. Create from structured JSON

Use structured JSON when your application already owns the narrative and slide data. Presenton applies the chosen layouts and renders the presentation without planning the story from a prompt.

Six labeled steps showing template selection, schema inspection, slide JSON construction, validation, and rendering

The live template schema is the contract between your slide data and the renderer.

Call List Standard templates and choose a template ID.
Call Get a Standard template and read the id and json_schema for each layout.
Build each slide with a layout from that template and a content object that satisfies the selected layout schema.
Send the validated slides to Create from JSON synchronously.

curl --request GET \
  --url https://api.presenton.ai/api/v3/standard-template/neo-modern \
  --header "Authorization: Bearer YOUR_API_KEY"

curl --request POST \
  --url https://api.presenton.ai/api/v3/presentation/from-json \
  --header "Authorization: Bearer YOUR_API_KEY" \
  --header "Content-Type: application/json" \
  --data '{
    "standard_template": "neo-modern",
    "slides": [
      {
        "layout": "REPLACE_WITH_LAYOUT_ID",
        "content": {
          "title": "Q2 customer health",
          "bullets": [
            "Enterprise retention remained above target",
            "Time to first value improved",
            "Support response time needs attention"
          ]
        }
      }
    ]
  }'

The property names inside content are examples. Always use the live json_schema returned for the selected layout.

6. Generate with your own AI agent

This workflow gives your agent control over slide selection and content while Presenton remains responsible for template rendering and export.

Six labeled steps showing template contracts and source content sent to an AI agent, validated, and rendered by Presenton

Your agent writes slide JSON; your application validates it before Presenton renders the deck.

Give the agent the template contract

Call List Standard templates so the user can choose a template.
Call Get a Standard template to retrieve every layout ID and its json_schema.
Call Get a template example to retrieve representative layout and content pairs.
Give the schemas, examples, user content, and presentation goal to your AI agent.
Validate the agent response against the live schemas in your application.
Send the validated result to Create from JSON synchronously.

curl --request GET \
  --url https://api.presenton.ai/api/v3/standard-template/neo-modern \
  --header "Authorization: Bearer YOUR_API_KEY"

curl --request GET \
  --url https://api.presenton.ai/api/v3/standard-template/neo-modern/example \
  --header "Authorization: Bearer YOUR_API_KEY"

Agent instruction

Use an instruction like this with the AI provider in your application:

You create structured slide content for Presenton.

Build a coherent presentation for the user's goal using only the supplied
template layouts. For every slide:
- select one supplied layout ID;
- return a content object that satisfies that layout's JSON Schema;
- follow the supplied template examples for content density and structure;
- preserve all facts, names, dates, and figures from the user material;
- do not invent fields that are not allowed by the schema.

Return JSON only in this shape:
{
  "standard_template": "<selected template id>",
  "slides": [
    {
      "layout": "<layout id>",
      "content": {}
    }
  ]
}

Treat agent output as untrusted input. Reject unknown layouts, validate each content object, enforce slide and string limits, and only then call POST /presentation/from-json.

7. Run background jobs with async APIs and webhooks

Use background processing when generation should not hold an interactive HTTP request open. Presenton returns a task ID immediately and completes the work in the background.

A labeled async workflow showing task creation followed by polling or webhook delivery and a completed presentation

Start one background job, then resolve it through polling or webhook delivery.

Poll for completion

Use polling when your application does not expose a public callback URL.

curl --request POST \
  --url https://api.presenton.ai/api/v3/presentation/generate/async \
  --header "Authorization: Bearer YOUR_API_KEY" \
  --header "Content-Type: application/json" \
  --data '{
    "content": "Create an eight-slide executive briefing about the rollout of a new customer analytics platform."
  }'

Store the returned id, then poll with a capped delay until status becomes completed or error:

curl --request GET \
  --url https://api.presenton.ai/api/v3/async-task/status/REPLACE_WITH_TASK_ID \
  --header "Authorization: Bearer YOUR_API_KEY"

Receive completion through a webhook

Use webhook delivery when your application has a stable HTTPS receiver. Subscribe each event your receiver needs, then enable delivery on the async generation request.

curl --request POST \
  --url https://api.presenton.ai/api/v3/webhook/subscribe \
  --header "Authorization: Bearer YOUR_API_KEY" \
  --header "Content-Type: application/json" \
  --data '{
    "url": "https://app.example.com/webhooks/presenton",
    "secret": "REPLACE_WITH_A_RANDOM_SECRET",
    "event": "presentation.generation.completed"
  }'

curl --request POST \
  --url https://api.presenton.ai/api/v3/presentation/generate/async \
  --header "Authorization: Bearer YOUR_API_KEY" \
  --header "Content-Type: application/json" \
  --data '{
    "content": "Create an eight-slide executive briefing about the rollout of a new customer analytics platform.",
    "trigger_webhook": true
  }'

Subscribe presentation.generation.failed to receive failed jobs as well. Verify the webhook secret, acknowledge delivery quickly, and process repeated events idempotently.See Generate a presentation asynchronously, Get task status, and Subscribe a webhook.

Start at Flow 1 and stop when the workflow matches your product.

Prompt → sources → design → structure → agents → background jobs

These workflows use the self-hosted API v1 at http://localhost:5001/api/v1. Replace the origin with your deployment and keep every file path, template name, task ID, and presentation ID on that instance.

Before you begin

Start Presenton, configure the required AI providers, and have the primary administrator generate a Presenton API key. Store the instance URL and key outside your source code:

export PRESENTON_URL=http://localhost:5001
export PRESENTON_API_KEY=sk-presenton-REPLACE_WITH_YOUR_KEY

Send the API key as Authorization: Bearer $PRESENTON_API_KEY.

1. Generate a presentation directly

The synchronous v1 endpoint waits for generation and export to finish before returning the presentation result.

Five labeled steps showing direct presentation generation on a self-hosted Presenton instance

Your configured instance turns one prompt into an editable presentation.

content is the only required request field. The instance uses its configured defaults for slide count, language, template, title slide, and PPTX export.

curl --request POST \
  --url "$PRESENTON_URL/api/v1/ppt/presentation/generate" \
  --header "Authorization: Bearer $PRESENTON_API_KEY" \
  --header "Content-Type: application/json" \
  --data '{
    "content": "Create a seven-slide customer-facing launch deck for Atlas Analytics. The audience is enterprise operations leaders. Cover the problem, new capabilities, proof points, rollout plan, security, and next steps. Use concise executive language and do not invent customer metrics."
  }'

See Generate a presentation synchronously.

2. Generate from uploaded files

Five labeled steps showing source files uploaded to an instance and their returned paths used for generation

Keep the returned file paths on the same instance that performs generation.

curl --request POST \
  --url "$PRESENTON_URL/api/v1/ppt/files/upload" \
  --header "Authorization: Bearer $PRESENTON_API_KEY" \
  --form "files=@./quarterly-report.pdf"

Pass the returned path in files:

curl --request POST \
  --url "$PRESENTON_URL/api/v1/ppt/presentation/generate" \
  --header "Authorization: Bearer $PRESENTON_API_KEY" \
  --header "Content-Type: application/json" \
  --data '{
    "content": "Create an executive quarterly review from the uploaded report. Preserve every reported figure exactly.",
    "files": ["REPLACE_WITH_RETURNED_FILE_PATH"]
  }'

See Upload source files.

3. Generate with an installed template

Open Source v1 supports Standard generation with installed templates. It does not expose Cloud Smart Designs or a public template-list endpoint.

Five labeled steps showing an installed template name added to an Open Source generation request

Use the installed template name configured on your own Presenton instance.

curl --request POST \
  --url "$PRESENTON_URL/api/v1/ppt/presentation/generate" \
  --header "Authorization: Bearer $PRESENTON_API_KEY" \
  --header "Content-Type: application/json" \
  --data '{
    "content": "Create a six-slide partner enablement presentation for a new analytics product.",
    "template": "general"
  }'

Smart mode and smart_design belong to Presenton Cloud. Open Source uses the installed template named in template.

4. Import a PPTX template and generate

Template import happens in the Presenton interface. After validating fonts, layouts, and representative content, use the saved template name in v1 generation requests.

Five labeled steps showing a PPTX imported on a self-hosted instance, saved as an installed template, and used for generation

Import in the interface, then use the saved template name in API requests.

curl --request POST \
  --url "$PRESENTON_URL/api/v1/ppt/presentation/generate" \
  --header "Authorization: Bearer $PRESENTON_API_KEY" \
  --header "Content-Type: application/json" \
  --data '{
    "content": "Create a seven-slide annual strategy presentation for the leadership offsite.",
    "template": "REPLACE_WITH_IMPORTED_TEMPLATE_NAME"
  }'

Follow Create a template from PPTX for the import workflow.

5. Run background jobs with async APIs and webhooks

A labeled self-hosted async workflow showing task creation, polling or webhook delivery, and a completed presentation

Queue work on your instance and finish through polling or webhook delivery.

Poll for completion

curl --request POST \
  --url "$PRESENTON_URL/api/v1/ppt/presentation/generate/async" \
  --header "Authorization: Bearer $PRESENTON_API_KEY" \
  --header "Content-Type: application/json" \
  --data '{
    "content": "Create an eight-slide executive briefing about the rollout of a new customer analytics platform."
  }'

curl --request GET \
  --url "$PRESENTON_URL/api/v1/ppt/presentation/status/REPLACE_WITH_TASK_ID" \
  --header "Authorization: Bearer $PRESENTON_API_KEY"

Receive a webhook

Subscribe the instance, then set trigger_webhook to true in the async generation request.

curl --request POST \
  --url "$PRESENTON_URL/api/v1/webhook/subscribe" \
  --header "Authorization: Bearer $PRESENTON_API_KEY" \
  --header "Content-Type: application/json" \
  --data '{
    "url": "https://app.example.com/webhooks/presenton",
    "secret": "REPLACE_WITH_A_RANDOM_SECRET",
    "event": "presentation.generation.completed"
  }'

curl --request POST \
  --url "$PRESENTON_URL/api/v1/ppt/presentation/generate/async" \
  --header "Authorization: Bearer $PRESENTON_API_KEY" \
  --header "Content-Type: application/json" \
  --data '{
    "content": "Create an eight-slide executive briefing about the rollout of a new customer analytics platform.",
    "trigger_webhook": true
  }'

See Generate asynchronously, Get generation status, and Subscribe a webhook.

Use the Open Source tab for APIs hosted by your own Presenton instance.

Prompt → sources → installed template → background jobs

API guides

API reference

From one prompt to a polished presentation.

Before you begin

1. Generate a presentation directly

2. Generate from uploaded files

Upload the files

Generate from those values

3. Generate in Standard or Smart mode

Standard mode

Smart mode

4. Import a PPTX template and generate

5. Create from structured JSON

6. Generate with your own AI agent

Give the agent the template contract

Agent instruction

7. Run background jobs with async APIs and webhooks

Poll for completion

Receive completion through a webhook

Before you begin

1. Generate a presentation directly

2. Generate from uploaded files

3. Generate with an installed template

4. Import a PPTX template and generate

5. Run background jobs with async APIs and webhooks

Poll for completion

Receive a webhook

​From one prompt to a polished presentation.

​Before you begin

​1. Generate a presentation directly

​2. Generate from uploaded files

​Upload the files

​Generate from those values

​3. Generate in Standard or Smart mode

​Standard mode

​Smart mode

​4. Import a PPTX template and generate

​5. Create from structured JSON

​6. Generate with your own AI agent

​Give the agent the template contract

​Agent instruction

​7. Run background jobs with async APIs and webhooks

​Poll for completion

​Receive completion through a webhook

​Before you begin

​1. Generate a presentation directly

​2. Generate from uploaded files

​3. Generate with an installed template

​4. Import a PPTX template and generate

​5. Run background jobs with async APIs and webhooks

​Poll for completion

​Receive a webhook

From one prompt to a polished presentation.

Before you begin

1. Generate a presentation directly

2. Generate from uploaded files

Upload the files

Generate from those values

3. Generate in Standard or Smart mode

Standard mode

Smart mode

4. Import a PPTX template and generate

5. Create from structured JSON

6. Generate with your own AI agent

Give the agent the template contract

Agent instruction

7. Run background jobs with async APIs and webhooks

Poll for completion

Receive completion through a webhook

Before you begin

1. Generate a presentation directly

2. Generate from uploaded files

3. Generate with an installed template

4. Import a PPTX template and generate

5. Run background jobs with async APIs and webhooks

Poll for completion

Receive a webhook