# Generate presentations with the API
Source: https://docs.presenton.ai/api-guides/presentation-generation-flows

Start with one prompt, then progress through files, design modes, templates, structured JSON, AI agents, and background jobs.

<div>
  <p>PRESENTON API GUIDE</p>
  <h2>From one prompt to a polished presentation.</h2>

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

  <div aria-label="Available Presenton deployments">
    <div>
      <p>Cloud</p>
      <p>Managed API · v3</p>
    </div>

    <div>
      <p>Open Source</p>
      <p>Self-hosted API · v1</p>
    </div>
  </div>
</div>

<Tabs>
  <Tab title="Cloud">
    <Note>
      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.
    </Note>

    ## Before you begin

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

    ```http theme={null}
    Authorization: Bearer YOUR_API_KEY
    ```

    The response from a completed generation request contains:

    ```json theme={null}
    {
      "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.

    <div>
      <img alt="Four labeled steps showing a prompt sent to the Presenton API, generated, and returned as an editable presentation" />

      <p>Direct generation turns one prompt into an editable presentation and exported PPTX.</p>
    </div>

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

    ```bash theme={null}
    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](../api-reference/v3-presentation/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.

    <div>
      <img alt="Five labeled steps showing source files uploaded, saved as file values, and used to generate a grounded presentation" />

      <p>Upload the sources once, then pass their returned file values into generation.</p>
    </div>

    ### Upload the files

    ```bash theme={null}
    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:

    ```json theme={null}
    [
      "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.

    ```bash theme={null}
    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](../api-reference/v3-files/upload-source-files) and
    [Generate a presentation synchronously](../api-reference/v3-presentation/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.

    <div>
      <img alt="A labeled decision diagram comparing Standard mode reusable layouts with Smart mode adaptive composition" />

      <p>Standard and Smart are alternative design paths for the same generation request.</p>
    </div>

    ### Standard mode

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

    ```bash theme={null}
    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:

    ```bash theme={null}
    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.

    ```bash theme={null}
    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:

    ```bash theme={null}
    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](../api-reference/v3-standard-template/list-standard-templates)
    and [List Smart Designs](../api-reference/v3-smart-design/list-smart-designs).

    To create a custom Smart Design from a reference PPTX before generating, follow
    the [Smart Generation guide](./smart-generation).

    ## 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.

    <div>
      <img alt="Five labeled steps showing a filled PPTX imported in Template Studio, saved as a template, and used through the API" />

      <p>Template Studio converts a branded PPTX into a reusable template for API generation.</p>
    </div>

    1. Import the filled PPTX in Template Studio, resolve missing fonts, review the
       detected layouts, and save the template. Follow
       [Create a template from PPTX](../user-guide/branding-and-design/templates).
    2. List the account's Standard templates and find the saved template ID.
    3. Send that ID as `standard_template` in the synchronous generation request.

    ```bash theme={null}
    curl --request GET \
      --url https://api.presenton.ai/api/v3/standard-template/all \
      --header "Authorization: Bearer YOUR_API_KEY"
    ```

    ```bash theme={null}
    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.

    <div>
      <img alt="Six labeled steps showing template selection, schema inspection, slide JSON construction, validation, and rendering" />

      <p>The live template schema is the contract between your slide data and the renderer.</p>
    </div>

    1. Call [List Standard templates](../api-reference/v3-standard-template/list-standard-templates)
       and choose a template ID.
    2. Call [Get a Standard template](../api-reference/v3-standard-template/get-a-standard-template)
       and read the `id` and `json_schema` for each layout.
    3. Build each slide with a `layout` from that template and a `content` object
       that satisfies the selected layout schema.
    4. Send the validated slides to
       [Create from JSON synchronously](../api-reference/v3-presentation/create-from-json-synchronously).

    ```bash theme={null}
    curl --request GET \
      --url https://api.presenton.ai/api/v3/standard-template/neo-modern \
      --header "Authorization: Bearer YOUR_API_KEY"
    ```

    ```bash theme={null}
    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.

    For the complete discovery-to-rendering workflow, including template examples,
    follow the [Create Presentation from JSON guide](./standard-from-json).

    ## 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.

    <div>
      <img alt="Six labeled steps showing template contracts and source content sent to an AI agent, validated, and rendered by Presenton" />

      <p>Your agent writes slide JSON; your application validates it before Presenton renders the deck.</p>
    </div>

    ### Give the agent the template contract

    1. Call [List Standard templates](../api-reference/v3-standard-template/list-standard-templates)
       so the user can choose a template.
    2. Call [Get a Standard template](../api-reference/v3-standard-template/get-a-standard-template)
       to retrieve every layout ID and its `json_schema`.
    3. Call [Get a template example](../api-reference/v3-standard-template/get-a-template-example)
       to retrieve representative `layout` and `content` pairs.
    4. Give the schemas, examples, user content, and presentation goal to your AI
       agent.
    5. Validate the agent response against the live schemas in your application.
    6. Send the validated result to
       [Create from JSON synchronously](../api-reference/v3-presentation/create-from-json-synchronously).

    ```bash theme={null}
    curl --request GET \
      --url https://api.presenton.ai/api/v3/standard-template/neo-modern \
      --header "Authorization: Bearer YOUR_API_KEY"
    ```

    ```bash theme={null}
    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:

    ```text theme={null}
    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.

    <div>
      <img alt="A labeled async workflow showing task creation followed by polling or webhook delivery and a completed presentation" />

      <p>Start one background job, then resolve it through polling or webhook delivery.</p>
    </div>

    ### Poll for completion

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

    ```bash theme={null}
    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`:

    ```bash theme={null}
    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.

    ```bash theme={null}
    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"
      }'
    ```

    ```bash theme={null}
    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](../api-reference/v3-presentation/generate-a-presentation-asynchronously),
    [Get task status](../api-reference/v3-async-task/get-task-status), and
    [Subscribe a webhook](../api-reference/v3-webhook/subscribe-a-webhook).

    <div>
      <p>Start at Flow 1 and stop when the workflow matches your product.</p>
      <span>Prompt → sources → design → structure → agents → background jobs</span>
    </div>
  </Tab>

  <Tab title="Open Source">
    <Note>
      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.
    </Note>

    ## 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:

    ```bash theme={null}
    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.

    <div>
      <img alt="Five labeled steps showing direct presentation generation on a self-hosted Presenton instance" />

      <p>Your configured instance turns one prompt into an editable presentation.</p>
    </div>

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

    ```bash theme={null}
    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](../api-reference/presentation/generate-a-presentation-synchronously).

    ## 2. Generate from uploaded files

    <div>
      <img alt="Five labeled steps showing source files uploaded to an instance and their returned paths used for generation" />

      <p>Keep the returned file paths on the same instance that performs generation.</p>
    </div>

    ```bash theme={null}
    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`:

    ```bash theme={null}
    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](../api-reference/files/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.

    <div>
      <img alt="Five labeled steps showing an installed template name added to an Open Source generation request" />

      <p>Use the installed template name configured on your own Presenton instance.</p>
    </div>

    ```bash theme={null}
    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"
      }'
    ```

    <Info>
      Smart mode and `smart_design` belong to Presenton Cloud. Open Source
      uses the installed template named in `template`.
    </Info>

    ## 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.

    <div>
      <img alt="Five labeled steps showing a PPTX imported on a self-hosted instance, saved as an installed template, and used for generation" />

      <p>Import in the interface, then use the saved template name in API requests.</p>
    </div>

    ```bash theme={null}
    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](../user-guide/branding-and-design/templates)
    for the import workflow.

    ## 5. Run background jobs with async APIs and webhooks

    <div>
      <img alt="A labeled self-hosted async workflow showing task creation, polling or webhook delivery, and a completed presentation" />

      <p>Queue work on your instance and finish through polling or webhook delivery.</p>
    </div>

    ### Poll for completion

    ```bash theme={null}
    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."
      }'
    ```

    ```bash theme={null}
    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.

    ```bash theme={null}
    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"
      }'
    ```

    ```bash theme={null}
    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](../api-reference/presentation/generate-a-presentation-asynchronously),
    [Get generation status](../api-reference/presentation/get-generation-status),
    and [Subscribe a webhook](../api-reference/webhook/subscribe-a-webhook).

    <div>
      <p>Use the Open Source tab for APIs hosted by your own Presenton instance.</p>
      <span>Prompt → sources → installed template → background jobs</span>
    </div>
  </Tab>
</Tabs>


# Create and use a Smart Design
Source: https://docs.presenton.ai/api-guides/smart-generation

List Smart Designs, create one from a reference PPTX with an access token, and use it to generate a Cloud presentation.

Smart generation applies the visual language of an existing presentation to a
new deck. Use an existing Smart Design or create one from a reference PPTX.

This workflow crosses two API versions:

1. List available Smart Designs with Cloud API v3.
2. Check fonts, upload the PPTX and fonts, generate previews, and create a
   Smart Design with API v2.
3. Pass the resulting design ID to Cloud API v3 presentation generation.

## Before you begin

Use a user access token that is authorized to create designs. Pass it as a
Bearer token on every request in this workflow:

```http theme={null}
Authorization: Bearer YOUR_ACCESS_TOKEN
```

<Note>
  All endpoints in this workflow require a user access token. Use the same
  access token for the v2 design-creation and Cloud v3 requests.
</Note>

## 1. List Smart Designs with v3

List the Smart Designs available to the authenticated account:

```bash theme={null}
curl --request GET \
  --url "https://api.presenton.ai/api/v3/smart-design/all?page=1&page_size=10" \
  --header "Authorization: Bearer YOUR_ACCESS_TOKEN"
```

The response is paginated. Use the `id` of a design as `smart_design` when
generating a presentation.

```json theme={null}
{
  "total_pages": 1,
  "page": 1,
  "page_size": 10,
  "results": [
    {
      "id": "7e49d7f0-3667-4f48-936a-60b0ca97810f",
      "name": "Acme Brand",
      "thumbnail_url": "https://example.com/designs/acme-brand.png",
      "created_at": "2026-08-07T08:30:00Z",
      "updated_at": "2026-08-07T08:30:00Z"
    }
  ]
}
```

See [List Smart Designs](../api-reference/v3-smart-design/list-smart-designs).
If the design you need is already listed, skip to
[Generate with the Smart Design](#3-generate-with-the-smart-design-using-v3).

## 2. Create a Smart Design with v2

Design creation is asynchronous. Check the reference deck's fonts, upload any
required replacements and generate previews, then start design creation and
poll its status.

### Check fonts in the reference PPTX

Upload the PPTX to identify fonts Presenton can resolve and fonts for which you
must provide files:

```bash theme={null}
curl --request POST \
  --url https://api.presenton.ai/api/v2/ppt/fonts/check \
  --header "Authorization: Bearer YOUR_ACCESS_TOKEN" \
  --form "pptx_file=@./acme-brand.pptx"
```

```json theme={null}
{
  "available_fonts": [
    {
      "name": "Inter Regular",
      "url": "https://fonts.googleapis.com/css2?family=Inter",
      "original_name": "Inter",
      "variant": "regular"
    }
  ],
  "unavailable_fonts": [
    {
      "name": "Acme Sans Regular",
      "url": null,
      "original_name": "Acme Sans",
      "variant": "regular"
    }
  ]
}
```

See [Check fonts in a PPTX](../api-reference/v2-fonts/check-fonts-in-a-pptx).

### Upload fonts and generate previews

Upload the same PPTX. For each font you want to replace, add one `font_files`
field and one matching `original_font_names` field. Presenton pairs repeated
fields by order.

```bash theme={null}
curl --request POST \
  --url https://api.presenton.ai/api/v2/ppt/fonts/upload-and-preview \
  --header "Authorization: Bearer YOUR_ACCESS_TOKEN" \
  --form "pptx_file=@./acme-brand.pptx" \
  --form "font_files=@./AcmeSans-Regular.ttf" \
  --form "original_font_names=Acme Sans"
```

If no font files are required, omit `font_files` and `original_font_names`.

```json theme={null}
{
  "slide_image_urls": [
    "https://example.com/previews/acme-brand/slide-1.png",
    "https://example.com/previews/acme-brand/slide-2.png"
  ],
  "pptx_url": "https://example.com/uploads/acme-brand.pptx",
  "modified_pptx_url": "https://example.com/uploads/acme-brand.pptx",
  "fonts": {
    "Inter": "https://fonts.googleapis.com/css2?family=Inter",
    "Acme Sans Regular": "https://example.com/fonts/AcmeSans-Regular.ttf"
  }
}
```

Review every URL in `slide_image_urls` before creating the design. Then retain
`pptx_url`, `slide_image_urls`, and `fonts` for the next request.

See [Upload fonts and generate slide previews](../api-reference/v2-fonts/upload-fonts-and-generate-slide-previews).

### Start asynchronous design creation

Pass `pptx_url`, `slide_image_urls`, and `fonts` from the preview response
without modifying them:

```bash theme={null}
curl --request POST \
  --url https://api.presenton.ai/api/v2/ppt/design/create/async \
  --header "Authorization: Bearer YOUR_ACCESS_TOKEN" \
  --header "Content-Type: application/json" \
  --data '{
    "name": "Acme Brand",
    "pptx_url": "https://example.com/uploads/acme-brand.pptx",
    "slide_image_urls": [
      "https://example.com/previews/acme-brand/slide-1.png",
      "https://example.com/previews/acme-brand/slide-2.png"
    ],
    "fonts": {
      "Inter": "https://fonts.googleapis.com/css2?family=Inter",
      "Acme Sans Regular": "https://example.com/fonts/AcmeSans-Regular.ttf"
    }
  }'
```

The response contains the task ID used to monitor design creation:

```json theme={null}
{
  "id": "task-9a827c13f4",
  "status": "pending",
  "message": "Queued for extraction",
  "created_at": "2026-08-07T08:35:00Z",
  "updated_at": "2026-08-07T08:35:00Z",
  "data": null
}
```

See [Create a Smart Design asynchronously](../api-reference/v2-design/create-a-smart-design-asynchronously).

### Check design creation status

Poll the status endpoint until `status` is `completed` or `error`:

```bash theme={null}
curl --request GET \
  --url https://api.presenton.ai/api/v2/ppt/design/status/task-9a827c13f4 \
  --header "Authorization: Bearer YOUR_ACCESS_TOKEN"
```

While the task runs, `status` is `pending` or `processing`. A completed
response contains the new Smart Design ID in `data.design_id`:

```json theme={null}
{
  "id": "task-9a827c13f4",
  "status": "completed",
  "message": "Design created",
  "created_at": "2026-08-07T08:35:00Z",
  "updated_at": "2026-08-07T08:43:00Z",
  "data": {
    "id": "7e49d7f0-3667-4f48-936a-60b0ca97810f",
    "design_id": "7e49d7f0-3667-4f48-936a-60b0ca97810f",
    "slides": 12
  },
  "error": null
}
```

If `status` is `error`, inspect `message` and `error` before retrying. See
[Get Smart Design creation status](../api-reference/v2-design/get-smart-design-creation-status).

## 3. Generate with the Smart Design using v3

Set `smart_design` to an ID returned by the list endpoint or to
`data.design_id` from the completed design-creation task:

```bash theme={null}
curl --request POST \
  --url https://api.presenton.ai/api/v3/presentation/generate \
  --header "Authorization: Bearer YOUR_ACCESS_TOKEN" \
  --header "Content-Type: application/json" \
  --data '{
    "content": "Create an eight-slide Acme quarterly business review.",
    "n_slides": 8,
    "language": "English",
    "smart_design": "7e49d7f0-3667-4f48-936a-60b0ca97810f",
    "export_as": "pptx"
  }'
```

```json theme={null}
{
  "presentation_id": "d3000f96-096c-4768-b67b-e99aed029b57",
  "path": "https://example.com/presentations/Acme-quarterly-business-review.pptx",
  "edit_path": "https://presenton.ai/presentation?id=d3000f96-096c-4768-b67b-e99aed029b57",
  "credits_consumed": 8
}
```

See [Generate a presentation synchronously](../api-reference/v3-presentation/generate-a-presentation-synchronously).
For background generation, send the same `smart_design` value to
`POST /api/v3/presentation/generate/async` and follow the
[asynchronous generation guide](../cloud/guides/async-generation).


# Create a presentation from JSON
Source: https://docs.presenton.ai/api-guides/standard-from-json

Discover a Standard template's layouts and schemas, inspect its example content, and create a presentation from validated JSON.

Use this workflow when your application already owns the slide content and
needs Presenton to render it with a Standard template. Each slide selects a
template layout and supplies a `content` object that satisfies that layout's
JSON schema.

## Before you begin

Create a Cloud API key and pass it as a Bearer token on every request:

```http theme={null}
Authorization: Bearer YOUR_API_KEY
```

## 1. Get Standard templates

List the templates available to the authenticated Cloud account:

```bash theme={null}
curl --request GET \
  --url "https://api.presenton.ai/api/v3/standard-template/all?page=1&page_size=20" \
  --header "Authorization: Bearer YOUR_API_KEY"
```

```json theme={null}
{
  "items": [
    {
      "id": "neo-modern",
      "name": "Neo Modern",
      "description": "A clean, modern presentation template",
      "layout_count": 12,
      "thumbnail": "https://example.com/templates/neo-modern.png",
      "is_default": true,
      "created_at": "2026-08-07T08:30:00Z",
      "updated_at": "2026-08-07T08:30:00Z"
    }
  ],
  "total": 1,
  "page": 1,
  "page_size": 20
}
```

Save the selected template's `id`. You will use it in the next three requests.
Use the optional `default` query parameter to filter the list: `true` returns
default templates and `false` returns custom templates.

See [List Standard templates](../api-reference/v3-standard-template/list-standard-templates).

## 2. Get the template and its schemas

Retrieve the selected template by ID:

```bash theme={null}
curl --request GET \
  --url https://api.presenton.ai/api/v3/standard-template/neo-modern \
  --header "Authorization: Bearer YOUR_API_KEY"
```

The response includes one entry in `schemas` for each template layout. The
schema's `title` is the layout ID to send as `slides[].layout`. The entire
`slides[].content` object must validate against the corresponding schema.

```json theme={null}
{
  "id": "neo-modern",
  "name": "Neo Modern",
  "description": "A clean, modern presentation template",
  "layout_count": 12,
  "thumbnail": "https://example.com/templates/neo-modern.png",
  "is_default": true,
  "created_at": "2026-08-07T08:30:00Z",
  "updated_at": "2026-08-07T08:30:00Z",
  "merged_components": {},
  "layouts": {
    "layouts": [
      {
        "id": "title-and-bullets",
        "description": "A title followed by a concise list"
      }
    ]
  },
  "fonts": {
    "Inter": "https://fonts.googleapis.com/css2?family=Inter"
  },
  "schemas": [
    {
      "title": "title-and-bullets",
      "type": "object",
      "properties": {
        "main": {
          "type": "object",
          "properties": {
            "title": {
              "type": "string",
              "minLength": 8,
              "maxLength": 80
            },
            "bullets": {
              "type": "array",
              "items": {
                "type": "string"
              },
              "minItems": 2,
              "maxItems": 5
            }
          },
          "required": ["title", "bullets"]
        }
      },
      "required": ["main"]
    }
  ]
}
```

<Note>
  The response above illustrates the shape of `schemas`. Layout IDs, component
  names, fields, types, and constraints vary by template. Always use the live
  response for the selected template.
</Note>

See [Get a Standard template](../api-reference/v3-standard-template/get-a-standard-template).

## 3. Get the template example

The example endpoint returns representative `layout` and `content` pairs that
already conform to the selected template's schemas:

```bash theme={null}
curl --request GET \
  --url https://api.presenton.ai/api/v3/standard-template/neo-modern/example \
  --header "Authorization: Bearer YOUR_API_KEY"
```

```json theme={null}
{
  "standard_template": "neo-modern",
  "slides": [
    {
      "layout": "title-and-bullets",
      "content": {
        "main": {
          "title": "Quarterly customer health",
          "bullets": [
            "Enterprise retention remained above target",
            "Time to first value improved",
            "Support response time needs attention"
          ]
        }
      }
    }
  ]
}
```

Use the example to understand the expected nesting and content density. Do not
assume the example fields apply to a different template or layout.

See [Get a template example](../api-reference/v3-standard-template/get-a-template-example).

## 4. Create the presentation from JSON

Build each slide with a layout from the selected template and content that
validates against that layout's schema. Then send the result to the synchronous
from-JSON endpoint:

```bash theme={null}
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 '{
    "title": "Quarterly customer health review",
    "language": "English",
    "standard_template": "neo-modern",
    "export_as": "pptx",
    "slides": [
      {
        "layout": "title-and-bullets",
        "content": {
          "main": {
            "title": "Quarterly customer health",
            "bullets": [
              "Enterprise retention remained above target",
              "Time to first value improved",
              "Support response time needs attention"
            ]
          }
        },
        "speaker_note": "Introduce the purpose and reporting period."
      }
    ]
  }'
```

```json theme={null}
{
  "presentation_id": "d3000f96-096c-4768-b67b-e99aed029b57",
  "path": "https://example.com/presentations/quarterly-customer-health.pptx",
  "edit_path": "https://presenton.ai/presentation?id=d3000f96-096c-4768-b67b-e99aed029b57",
  "credits_consumed": 1
}
```

See [Create from JSON synchronously](../api-reference/v3-presentation/create-from-json-synchronously).

Before submitting the request, validate each `content` object against its live
schema. This catches missing fields, incorrect value types, length violations,
and invalid array sizes before the rendering request.


# Delete a presentation
Source: https://docs.presenton.ai/api-reference/presentation/delete-a-presentation

/openapi/self-hosted.json delete /api/v1/ppt/presentation/{id}
Permanently delete one presentation from this instance.

[Read the presentation workflow guide](/api-guides/presentation-generation-flows).



# Derive a presentation
Source: https://docs.presenton.ai/api-reference/presentation/derive-a-presentation

/openapi/self-hosted.json post /api/v1/ppt/presentation/derive
Create a modified presentation while preserving the original.

[Read the presentation workflow guide](/api-guides/presentation-generation-flows).



# Edit a presentation
Source: https://docs.presenton.ai/api-reference/presentation/edit-a-presentation

/openapi/self-hosted.json post /api/v1/ppt/presentation/edit
Apply new content to an existing presentation and return the updated result.

[Read the presentation workflow guide](/api-guides/presentation-generation-flows).



# Async generation (self-hosted)
Source: https://docs.presenton.ai/api-reference/presentation/generate-a-presentation-asynchronously

/openapi/self-hosted.json post /api/v1/ppt/presentation/generate/async
Create a background generation task and return immediately with its task identifier.

[Read the presentation workflow guide](/api-guides/presentation-generation-flows).



# Sync generation (self-hosted)
Source: https://docs.presenton.ai/api-reference/presentation/generate-a-presentation-synchronously

/openapi/self-hosted.json post /api/v1/ppt/presentation/generate
Create and export a presentation before returning the final presentation paths.

[Read the presentation workflow guide](/api-guides/presentation-generation-flows).



# Get a presentation
Source: https://docs.presenton.ai/api-reference/presentation/get-a-presentation

/openapi/self-hosted.json get /api/v1/ppt/presentation/{id}
Return one presentation and its slides.

[Read the presentation workflow guide](/api-guides/presentation-generation-flows).



# Get generation status
Source: https://docs.presenton.ai/api-reference/presentation/get-generation-status

/openapi/self-hosted.json get /api/v1/ppt/presentation/status/{id}
Return the state and result or error data for an asynchronous presentation task.

[Read the async and webhooks guide](/user-guide/api-and-automation/async-and-webhooks).



# Presentations (self-hosted)
Source: https://docs.presenton.ai/api-reference/presentation/list-presentations

/openapi/self-hosted.json get /api/v1/ppt/presentation/all
List presentations stored by this Presenton instance.

[Read the presentation workflow guide](/api-guides/presentation-generation-flows).



# Edit a slide
Source: https://docs.presenton.ai/api-reference/slide/edit-a-slide

/openapi/self-hosted.json post /api/v1/ppt/slide/edit
Apply an AI-assisted edit to one stored slide.

[Read the presentation workflow guide](/api-guides/presentation-generation-flows).



# Create a Smart Design asynchronously
Source: https://docs.presenton.ai/api-reference/v2-design/create-a-smart-design-asynchronously

/openapi/cloud.json post /api/v2/ppt/design/create/async
Start creating a Smart Design from the uploaded PPTX, slide previews, and font assets.

[Read the Smart Generation guide](/api-guides/smart-generation).



# Get Smart Design creation status
Source: https://docs.presenton.ai/api-reference/v2-design/get-smart-design-creation-status

/openapi/cloud.json get /api/v2/ppt/design/status/{id}
Return the current state and result or error data for an asynchronous Smart Design creation task.

[Read the Smart Generation guide](/api-guides/smart-generation).



# Check fonts in a PPTX
Source: https://docs.presenton.ai/api-reference/v2-fonts/check-fonts-in-a-pptx

/openapi/cloud.json post /api/v2/ppt/fonts/check
Inspect a reference PPTX and report fonts that are available or require uploaded font files.

[Read the Smart Generation guide](/api-guides/smart-generation).



# Upload fonts and generate slide previews
Source: https://docs.presenton.ai/api-reference/v2-fonts/upload-fonts-and-generate-slide-previews

/openapi/cloud.json post /api/v2/ppt/fonts/upload-and-preview
Upload a reference PPTX and any replacement fonts, then return slide previews and assets used to create a Smart Design.

[Read the Smart Generation guide](/api-guides/smart-generation).



# Get task status
Source: https://docs.presenton.ai/api-reference/v3-async-task/get-task-status

/openapi/cloud.json get /api/v3/async-task/status/{id}
Return the current state and result or error data for an asynchronous Cloud task.

[Read the async and webhooks guide](/user-guide/api-and-automation/async-and-webhooks).



# Upload source files (Cloud)
Source: https://docs.presenton.ai/api-reference/v3-files/upload-source-files

/openapi/cloud.json post /api/v3/files/upload
Upload documents or other supported source files and return identifiers that can be used in Cloud generation requests.

[Read the files and content guide](/user-guide/api-and-automation/files-and-content).



# Delete image (Cloud)
Source: https://docs.presenton.ai/api-reference/v3-images/delete-an-uploaded-image

/openapi/cloud.json delete /api/v3/images/{id}
Delete one uploaded image owned by the authenticated Cloud account.

[Read the files and content guide](/user-guide/api-and-automation/files-and-content).



# Uploaded images (Cloud)
Source: https://docs.presenton.ai/api-reference/v3-images/list-uploaded-images

/openapi/cloud.json get /api/v3/images/uploaded
List images uploaded to the authenticated Cloud account.

[Read the files and content guide](/user-guide/api-and-automation/files-and-content).



# Upload image (Cloud)
Source: https://docs.presenton.ai/api-reference/v3-images/upload-an-image

/openapi/cloud.json post /api/v3/images/upload
Upload an image and return the identifier used by presentation workflows.

[Read the files and content guide](/user-guide/api-and-automation/files-and-content).



# Create a presentation integration token
Source: https://docs.presenton.ai/api-reference/v3-presentation/create-a-presentation-integration-token

/openapi/cloud.json post /api/v3/presentation/integrate
Create a temporary, scoped URL for embedding an existing Cloud presentation in an iframe.

[Read the iframe integration guide](/user-guide/managing-presentations/embed-presentation-preview).



# Create from JSON asynchronously
Source: https://docs.presenton.ai/api-reference/v3-presentation/create-from-json-asynchronously

/openapi/cloud.json post /api/v3/presentation/from-json/async
Create a background task that builds a presentation from structured slide content.

[Read the presentation workflow guide](/api-guides/presentation-generation-flows).



# Create from JSON synchronously
Source: https://docs.presenton.ai/api-reference/v3-presentation/create-from-json-synchronously

/openapi/cloud.json post /api/v3/presentation/from-json
Create and export a presentation from structured slide content before returning.

[Read the Create Presentation from JSON guide](/api-guides/standard-from-json).



# Export a presentation
Source: https://docs.presenton.ai/api-reference/v3-presentation/export-a-presentation

/openapi/cloud.json post /api/v3/presentation/export
Export an existing Cloud presentation in a supported output format.

[Read the presentation workflow guide](/api-guides/presentation-generation-flows).



# Async generation (Cloud)
Source: https://docs.presenton.ai/api-reference/v3-presentation/generate-a-presentation-asynchronously

/openapi/cloud.json post /api/v3/presentation/generate/async
Create a background Cloud generation task and return immediately with its task identifier.

[Read the presentation workflow guide](/api-guides/presentation-generation-flows).



# Sync generation (Cloud)
Source: https://docs.presenton.ai/api-reference/v3-presentation/generate-a-presentation-synchronously

/openapi/cloud.json post /api/v3/presentation/generate
Create and export a Cloud presentation before returning the final presentation paths.

[Read the presentation workflow guide](/api-guides/presentation-generation-flows).



# Generate an outline
Source: https://docs.presenton.ai/api-reference/v3-presentation/generate-an-outline

/openapi/cloud.json post /api/v3/presentation/outlines/generate
Generate a presentation outline without creating the final deck.

[Read the presentation workflow guide](/api-guides/presentation-generation-flows).



# Presentations (Cloud)
Source: https://docs.presenton.ai/api-reference/v3-presentation/list-presentations

/openapi/cloud.json get /api/v3/presentation/all
List presentations owned by the authenticated Cloud account.

[Read the presentation workflow guide](/api-guides/presentation-generation-flows).



# List Smart Designs
Source: https://docs.presenton.ai/api-reference/v3-smart-design/list-smart-designs

/openapi/cloud.json get /api/v3/smart-design/all
List Smart Designs available for Cloud presentation generation.

[Read the Smart Generation guide](/api-guides/smart-generation).



# Get a standard template
Source: https://docs.presenton.ai/api-reference/v3-standard-template/get-a-standard-template

/openapi/cloud.json get /api/v3/standard-template/{template_id}
Return metadata for one standard template.

[Read the Create Presentation from JSON guide](/api-guides/standard-from-json).



# Get a template example
Source: https://docs.presenton.ai/api-reference/v3-standard-template/get-a-template-example

/openapi/cloud.json get /api/v3/standard-template/{template_id}/example
Return the example presentation associated with a standard template.

[Read the Create Presentation from JSON guide](/api-guides/standard-from-json).



# List standard templates
Source: https://docs.presenton.ai/api-reference/v3-standard-template/list-standard-templates

/openapi/cloud.json get /api/v3/standard-template/all
List standard templates available to the authenticated Cloud account.

[Read the Create Presentation from JSON guide](/api-guides/standard-from-json).



# List webhook subscriptions
Source: https://docs.presenton.ai/api-reference/v3-webhook/list-webhook-subscriptions

/openapi/cloud.json get /api/v3/webhook/all
List webhook subscriptions owned by the authenticated Cloud account.

[Read the async and webhooks guide](/user-guide/api-and-automation/async-and-webhooks).



# Subscribe webhook (Cloud)
Source: https://docs.presenton.ai/api-reference/v3-webhook/subscribe-a-webhook

/openapi/cloud.json post /api/v3/webhook/subscribe
Subscribe an HTTPS endpoint to supported Presenton events.

[Read the async and webhooks guide](/user-guide/api-and-automation/async-and-webhooks).



# Unsubscribe webhook (Cloud)
Source: https://docs.presenton.ai/api-reference/v3-webhook/unsubscribe-a-webhook

/openapi/cloud.json delete /api/v3/webhook/unsubscribe
Remove one webhook subscription.

[Read the async and webhooks guide](/user-guide/api-and-automation/async-and-webhooks).



# Content sources
Source: https://docs.presenton.ai/general/content-sources

Choose focused prompts, files, and data for clearer AI-generated presentations.

A content source gives Presenton the subject matter for a deck. Your brief tells it what result to create; supporting material supplies the facts and detail.

## Choose the right input

| Source                | Best for                                    | Prepare it by                                               |
| --------------------- | ------------------------------------------- | ----------------------------------------------------------- |
| Prompt or brief       | A new deck based on a clear idea            | Naming the audience, goal, scope, and tone                  |
| Documents             | Summaries, proposals, training, or research | Removing irrelevant pages and identifying must-use sections |
| Structured data       | Reports and repeatable automation           | Using consistent fields, labels, units, and date ranges     |
| Existing presentation | Derivation or design-led workflows          | Removing stale slides and checking the source file          |
| Images and media      | Visual evidence or assets                   | Using relevant, legible, appropriately licensed files       |

## Brief + evidence works better than either alone

<img alt="Diagram showing a brief and evidence combining into generation input, then producing a focused outline" />

## Improve source quality

* Include only material relevant to the presentation goal.
* State which facts, quotes, dates, and figures must remain exact.
* Define acronyms and explain internal terminology.
* Make units and reporting periods explicit in structured data.
* Separate instructions from source content when possible.
* Avoid conflicting versions of the same document unless you explain which one should win.

<Warning>
  Uploaded or pasted material does not become automatically correct because it appears in a generated slide. Compare important output with the original source before delivery.
</Warning>

## Understand where content is processed

Cloud processes content through the managed service. In self-hosted deployments, the application runs on your infrastructure, but configured external providers may still receive prompts or derived content. Review your provider configuration and data-handling requirements before using sensitive material.

<Card title="Create presentations from source material" icon="file-lines" href="/user-guide/create-new-presentation#generation-essentials">
  Learn how documents, structured data, images, and charts enter the workflow.
</Card>


# Cloud and self-hosted deployment modes
Source: https://docs.presenton.ai/general/deployment-modes

Compare Presenton Cloud with the self-hosted open-source AI presentation generator.

Presenton is available as a managed Cloud service and as open-source software you run yourself. Both support the same core prompt-to-presentation journey, but they differ in setup, providers, storage, and API contracts.

The public `presenton/presenton` repository contains the self-hosted web application, Electron desktop packaging, FastAPI backend, Next.js frontend, templates, and deployment tooling. Cloud is a managed product surface and may not expose every repository capability in the same way.

## Compare the operating models

| Decision               | Cloud                     | Self-hosted                                         |
| ---------------------- | ------------------------- | --------------------------------------------------- |
| Best when              | You want to start quickly | You need infrastructure, data, and provider control |
| Application operations | Managed by Presenton      | Managed by you                                      |
| AI and media providers | Managed service           | You configure supported providers                   |
| Storage and backups    | Managed service           | Your responsibility                                 |
| User experience        | Browser                   | Browser with Docker, or desktop app                 |
| API                    | Cloud v3                  | Self-hosted v1                                      |
| Updates                | Delivered by Presenton    | You choose and deploy a release                     |
| License                | Managed service terms     | Apache 2.0 open-source code                         |

<Warning>
  Cloud v3 and self-hosted v1 use different base URLs, authentication, and endpoint paths. Treat them as separate integrations.
</Warning>

## Choose Cloud when

* You want to create in a browser without installing or operating Presenton.
* You prefer managed providers, processing, storage, and updates.
* You want the Cloud API for an integration.

## Choose self-hosted when

* Your organization needs to control the runtime, storage, and network boundary.
* You want to select supported text, image, search, or storage providers, including local or OpenAI-compatible providers.
* You need a local desktop workflow or an internally operated API.

<Note>
  Self-hosting alone does not make generation offline. Content may be sent to any external AI, image, or search provider you configure. Use local providers and review every dependency when an offline or restricted-data workflow is required.
</Note>

<CardGroup>
  <Card title="Start with Cloud" icon="cloud" href="/cloud/quickstart">
    Create a first presentation in the managed application.
  </Card>

  <Card title="Plan a self-hosted deployment" icon="server" href="/hosting/overview">
    Review installation, configuration, security, and operations.
  </Card>
</CardGroup>


# Feature availability
Source: https://docs.presenton.ai/general/feature-availability

Compare Cloud and self-hosted Presenton capabilities before choosing a workflow.

The creation workflow is shared, but feature availability and operating responsibility differ. Use this page as a quick comparison, then open the detailed guide for the capability you plan to use.

<Note>
  Capabilities can vary by release, account, deployment configuration, and selected presentation format. Use the version selector and test a representative deck before committing to a production workflow.
</Note>

## Capabilities

| Capability                          | Cloud                                                                        | Self-hosted                                      |
| ----------------------------------- | ---------------------------------------------------------------------------- | ------------------------------------------------ |
| Browser application                 | Available                                                                    | Available with a server deployment               |
| Desktop application                 | Not applicable                                                               | Available for Windows, macOS, and Linux          |
| Standard presentations              | Available                                                                    | Standard documented                              |
| Smart presentations                 | Available                                                                    | Available with Smart HTML generation and editing |
| Reusable custom templates           | Available                                                                    | Available                                        |
| Editable Standard object canvas     | Available with text, media, shape, table, chart, layout, and component tools | Same editor capabilities                         |
| Targeted AI editing                 | Available for selected slides and components                                 | Same editor capabilities                         |
| Slide management                    | Add, duplicate, delete, and reorder slides                                   | Same editor capabilities                         |
| PPTX and PDF export                 | Available                                                                    | Available                                        |
| REST API                            | Cloud v3                                                                     | Self-hosted v1                                   |
| Webhook workflows                   | Available                                                                    | Available                                        |
| MCP server                          | Not covered by this Cloud reference                                          | Available except in the desktop app              |
| Configurable AI and media providers | Managed service                                                              | Available                                        |
| Local model workflows               | Not user-configured                                                          | Available with compatible local providers        |

<Note>
  The shared Standard canvas exposes controls according to the selected object. Selecting an image shows image tools such as crop and flip; selecting a chart opens data, type, title, value, axis, gridline, color, and opacity controls.
</Note>

## Operating responsibility

| Responsibility                 | Cloud     | Self-hosted |
| ------------------------------ | --------- | ----------- |
| Application deployment         | Presenton | You         |
| Application updates            | Presenton | You         |
| Provider configuration         | Presenton | You         |
| Persistent storage and backups | Presenton | You         |
| Host security and TLS          | Presenton | You         |
| Capacity and health monitoring | Presenton | You         |

<Warning>
  “Available” does not mean identical. Cloud v3 and self-hosted v1 have different authentication, URLs, endpoints, and request schemas. Use the API reference for your deployment mode.
</Warning>

## Confirm before you commit to a workflow

1. Select the documentation version that matches the release you use.
2. Check the detailed guide for the capability—not only this summary.
3. Test a representative presentation, template, edit, and export.
4. For automation, validate the exact endpoint and schema in the relevant OpenAPI reference.

<CardGroup>
  <Card title="Compare deployment modes" icon="cloud-arrow-up" href="/general/deployment-modes">
    Choose between a managed and self-operated environment.
  </Card>

  <Card title="Open API Documentation" icon="brackets-curly" href="/user-guide/api-and-automation/overview">
    Select Cloud v3 or self-hosted v1 before integrating.
  </Card>
</CardGroup>


# Generation lifecycle
Source: https://docs.presenton.ai/general/generation-lifecycle

Understand the stages, checkpoints, and failure boundaries of AI presentation generation.

Generation is a sequence of work, not a single AI response. Knowing the stages helps you decide whether to revise the input, wait for a task, or troubleshoot a dependency.

<img alt="Diagram showing input ready, outline ready, generating, ready, editing, exported, and failed states" />

## Lifecycle stages

| Stage         | What happens                                             | What to check                                                    |
| ------------- | -------------------------------------------------------- | ---------------------------------------------------------------- |
| Input ready   | The brief, source files, and controls are collected      | Scope, file relevance, and must-keep facts                       |
| Outline ready | Presenton proposes the deck structure                    | Flow, coverage, repetition, and slide count                      |
| Generating    | Content, layouts, and visuals are assembled and rendered | Wait for completion; avoid duplicate submissions                 |
| Ready         | The presentation can be opened and reviewed              | Accuracy, design fit, and missing content                        |
| Editing       | You refine the generated result                          | Preserve verified facts while changing wording or layout         |
| Exported      | A PPTX or PDF is produced                                | Open the file and inspect fonts, charts, images, and page bounds |

## Synchronous and asynchronous API work

<Tabs>
  <Tab title="Synchronous">
    The request stays open while generation runs and returns after the operation completes or fails. Use it when the caller can safely wait for the full result.
  </Tab>

  <Tab title="Asynchronous">
    The request creates background work and returns a task identifier. Poll the deployment-specific status endpoint, or use a supported webhook workflow, until the task reaches a terminal state.
  </Tab>
</Tabs>

<Warning>
  Do not retry an asynchronous request only because generation is taking longer than expected. Check its task status first to avoid creating duplicate presentations.
</Warning>

## Where failures usually belong

* **Before outline creation:** inspect the input, upload, document processing, and provider configuration.
* **During generation:** inspect text, image, template, and rendering dependencies.
* **During export:** inspect fonts, assets, browser/export runtime, and storage.

<CardGroup>
  <Card title="API workflow" icon="code" href="/api/workflow">
    Implement the lifecycle with the correct API surface.
  </Card>

  <Card title="Troubleshoot generation" icon="screwdriver-wrench" href="/troubleshooting/generation">
    Diagnose a failed or incomplete generation.
  </Card>
</CardGroup>


# Get started
Source: https://docs.presenton.ai/general/get-started

Choose Cloud, Docker, or desktop and create your first presentation.

Pick one path. If you only want to try Presenton, Cloud is the shortest route. Choose Docker or desktop when you want to operate the open-source application and configure providers yourself.

<Tabs>
  <Tab title="Cloud">
    **Before you start:** Prepare a short topic or a focused source document.

    <Steps>
      <Step title="Open Presenton Cloud">
        Sign in to the [Presenton dashboard](https://presenton.ai/dashboard).
      </Step>

      <Step title="Describe the result">
        State the audience, purpose, desired slide count, and must-include points. Add source material when it should ground the deck.
      </Step>

      <Step title="Review the outline">
        Correct the structure and remove repetition before generating slides.
      </Step>

      <Step title="Generate and verify">
        Select a suitable template, generate the deck, then review every slide for accuracy and visual fit.
      </Step>

      <Step title="Export">
        Download the result as PPTX for continued editing or PDF for fixed-layout review.
      </Step>
    </Steps>

    <Card title="Cloud quickstart" icon="cloud" href="/cloud/quickstart">
      Follow the complete browser workflow.
    </Card>
  </Tab>

  <Tab title="Docker">
    **Before you start:** Confirm the [system requirements](/hosting/system-requirements) and decide which providers you will use.

    <Steps>
      <Step title="Start a release-pinned container">
        Follow the self-hosted quickstart and mount `/app_data` for persistent application data.
      </Step>

      <Step title="Configure providers">
        Add a supported text provider. Configure image, search, storage, and authentication options as required.
      </Step>

      <Step title="Open Presenton">
        Visit the host and port mapped to the container, then create and verify a small test deck.
      </Step>
    </Steps>

    <Card title="Self Host Presenton in Five Minutes" icon="docker" href="/hosting/overview">
      Install the documented release with persistent storage.
    </Card>
  </Tab>

  <Tab title="Desktop">
    **Before you start:** Choose a supported package for Windows, macOS, or Linux and have provider credentials ready if you will use a hosted model.

    <Steps>
      <Step title="Install the application">
        Download the correct package, install it, and open Presenton.
      </Step>

      <Step title="Choose a provider">
        Configure a supported hosted provider or a local model available to your machine.
      </Step>

      <Step title="Create a test deck">
        Use a short prompt first. Confirm generation and export work before adding large documents or custom templates.
      </Step>
    </Steps>

    <Card title="Desktop installation" icon="desktop" href="/self-hosted/tutorials/install-desktop-app">
      Download and verify the desktop application.
    </Card>
  </Tab>
</Tabs>

## A useful first brief

```text theme={null}
Create an 8-slide project update for executive stakeholders.
Focus on progress, risks, decisions needed, and next steps.
Use a concise, factual tone. Preserve all dates and figures from the source.
```

<Tip>
  A good brief names the audience, outcome, scope, tone, and facts that must not change.
</Tip>


# How Presenton works
Source: https://docs.presenton.ai/general/how-presenton-works

Follow the AI presentation workflow from source material to an editable PPTX or PDF.

Presenton separates **story planning** from **slide generation**. That gives you a useful checkpoint: approve the narrative before spending time on slide design.

In the current application, the outline is editable and can also be generated with AI assistance. Once you approve it, Presenton maps the story to a selected template, creates supported slide elements, fetches configured assets, and prepares the presentation for editing and export.

<img alt="Diagram showing direction and sources, outline review, slide generation, editing, and PPTX or PDF export" />

## 1. Add direction and sources

Provide a topic or brief. Add relevant files or structured input when the deck must reflect existing material. Generation controls can further describe tone, language, length, and visual preferences.

**Your checkpoint:** Is the goal clear, and is the source focused enough to support it?

## 2. Review the outline

Presenton proposes the narrative before building the deck. Reorder sections, remove weak ideas, and add missing details while the deck is still easy to reshape.

**Your checkpoint:** Would this outline make sense without seeing the slides?

## 3. Generate the slides

Presenton maps the approved story into the selected presentation format and template. It creates supported text, images, shapes, tables, charts, and layout elements for each slide.

**Your checkpoint:** Does the template suit the audience and content density?

## 4. Edit and verify

Refine the generated deck using the editing tools available in your deployment mode. Check names, dates, figures, claims, citations, layout, and image relevance.

Editing changes the generated presentation. It does not automatically send the deck back to the outline step; outline review happens before generation, and outline regeneration is a separate outline-page action.

**Your checkpoint:** Could someone act on incorrect content? If yes, verify it against the original source.

## 5. Export

Export to **PPTX** when the deck needs continued editing in PowerPoint-compatible software. Export to **PDF** when you need a fixed-layout review or delivery copy.

## What changes by deployment mode

<AccordionGroup>
  <Accordion title="Cloud" icon="cloud">
    Presenton manages the application, providers, processing, storage, and export runtime. Browser and API workflows use Cloud capabilities and the v3 API.
  </Accordion>

  <Accordion title="Self-hosted" icon="server">
    Your deployment uses the providers, storage, authentication, and compute you configure. Browser and automation workflows use the self-hosted application and v1 API.
  </Accordion>
</AccordionGroup>

<Card title="Understand the generation states" icon="arrows-rotate" href="/general/generation-lifecycle">
  Learn what happens during synchronous and asynchronous generation.
</Card>


# AI presentation maker overview
Source: https://docs.presenton.ai/general/overview

Use Presenton as an open-source AI presentation generator for editable PPTX and PDF decks.

Presenton is an open-source AI presentation generator for teams, developers, and creators who need more than a static slide image. Start with a prompt, document, data, or API request; review the outline; generate with a reusable design; edit the result; and export to **PPTX** or **PDF**.

## Watch Presenton in action

<video>
  Your browser does not support the video tag.
</video>

## Draft, edit, export

Presenton is built for the whole path from first draft to final deck. Generate a structured presentation, refine the editable slide elements, then export when it is ready to share.

<img alt="Diagram showing Presenton moving from Draft to Edit to Export, with PPTX and PDF outputs" />

## Start your way

<CardGroup>
  <Card title="Start in Presenton Cloud" icon="cloud" href="/cloud/quickstart">
    Create in the browser with managed infrastructure, providers, storage, and updates.
  </Card>

  <Card title="Run Presenton yourself" icon="server" href="/general/deployment-modes">
    Use Docker or the desktop app when you need control over deployment, storage, and model providers.
  </Card>
</CardGroup>

<Card title="Building a product or workflow? Start with the API" icon="brackets-curly" href="/user-guide/api-and-automation/overview">
  Use the presentation generation API to create, track, edit, and export decks from your own product or workflow.
</Card>

## One workflow, editable end to end

<div>
  <div>
    <span>1</span>
    <p>Give Presenton source material and review the outline.</p>
  </div>

  <div>
    <span>2</span>
    <p>Generate a deck with a reusable design or template.</p>
  </div>

  <div>
    <span>3</span>
    <p>Edit the result, verify the content, and export PPTX or PDF.</p>
  </div>
</div>

## Built for how you work

<div>
  <Tabs>
    <Tab title="Enterprises" icon="https://mintcdn.com/presenton-521d9e2f/oSISzG16Qh-yjB8A/images/welcome/audience-enterprises.svg?fit=max&auto=format&n=oSISzG16Qh-yjB8A&q=85&s=a6a180ee0c1ea24c6f710bf37ee5a4da">
      ### Keep sensitive presentation work under your control

      Self-host Presenton when privacy, compliance, or internal deployment requirements matter. You choose the infrastructure, storage, authentication, network boundary, and supported model providers.

      <Card title="Self-host Presenton" icon="building-shield" href="/hosting/overview">
        Start with Docker in five minutes and explore support for custom enterprise requirements.
      </Card>
    </Tab>

    <Tab title="Developers" icon="https://mintcdn.com/presenton-521d9e2f/oSISzG16Qh-yjB8A/images/welcome/audience-developers.svg?fit=max&auto=format&n=oSISzG16Qh-yjB8A&q=85&s=2838a8efffacc35f802ce8739909c468">
      ### Build presentation generation into your product

      Use REST APIs, asynchronous tasks, webhooks, or the self-hosted MCP workflow to create presentations from applications, internal tools, and recurring data processes.

      <Card title="Explore the APIs" icon="terminal" href="/user-guide/api-and-automation/overview">
        Compare Cloud v3 with self-hosted v1 before implementing an integration.
      </Card>
    </Tab>

    <Tab title="Creators" icon="https://mintcdn.com/presenton-521d9e2f/oSISzG16Qh-yjB8A/images/welcome/audience-creators.svg?fit=max&auto=format&n=oSISzG16Qh-yjB8A&q=85&s=9bc880297420bf336698c5bcbbb0d5fe">
      ### Design without losing editability

      Build branded decks with reusable templates and refine them on a structured canvas. Edit typography, images, shapes, tables, charts, layouts, slides, and selected components with targeted AI assistance.

      <Card title="Explore the authoring tools" icon="palette" href="/general/what-presenton-does">
        See the current creation, editing, template, and export capabilities.
      </Card>
    </Tab>
  </Tabs>
</div>

## Explore the documentation

<CardGroup>
  <Card title="User Guide" icon="book-open" href="/user-guide/create-new-presentation">
    Create, edit, brand, organize, and export presentations.
  </Card>

  <Card title="Hosting" icon="server" href="/hosting/overview">
    Install, configure, secure, and operate self-hosted Presenton.
  </Card>

  <Card title="API Documentation" icon="brackets-curly" href="/user-guide/api-and-automation/overview">
    Build with Cloud v3 or the self-hosted v1 API.
  </Card>

  <Card title="Troubleshooting" icon="screwdriver-wrench" href="/troubleshooting">
    Diagnose generation, editing, export, hosting, and integration problems.
  </Card>
</CardGroup>

<Note>
  AI-generated slides are a draft. Verify facts, figures, citations, and brand requirements before presenting or publishing them.
</Note>


# Presentation context
Source: https://docs.presenton.ai/general/presentation-context

Give editing requests enough context without relying on hidden assumptions.

Presentation context is the information available when Presenton interprets an editing request. Depending on the workflow, it can include the current deck, source material, outline, and recent instructions.

<img alt="Diagram showing the current deck, source material, outline, and user request feeding editing context, which produces a proposed update" />

Context helps with follow-up instructions such as “make this slide more concise” or “use the same tone in the next section.” It is not a guarantee that every earlier detail will be recalled or preserved.

## Write an actionable edit request

Use this pattern:

```text theme={null}
On slide 4, shorten the three risk descriptions to one sentence each.
Keep the risk names, owners, dates, and severity unchanged.
Use a direct executive tone.
```

| Include        | Example                                       |
| -------------- | --------------------------------------------- |
| Target         | “On slide 4” or “in the pricing section”      |
| Action         | “Shorten,” “replace,” “add,” or “restructure” |
| Constraint     | “Keep every figure unchanged”                 |
| Desired result | “Use three concise bullets”                   |

## Protect important information

* Repeat exact facts that must survive an edit.
* Name the slide, section, or element being changed.
* Point to the relevant source when the request depends on it.
* Split unrelated changes into separate requests.
* Review the visible result after every AI-assisted edit.

<Note>
  Treat the saved presentation—not assumed model memory—as the record of the current deck. If a detail matters, make it explicit in the request and verify it afterward.
</Note>

## Context and persistence

Cloud manages application storage for the hosted workflow. In a self-hosted deployment, keep `/app_data` persistent so presentations, uploads, generated assets, settings, and local application state survive container replacement.

<Card title="Storage and processing" icon="database" href="/self-hosted/configuration/storage-and-processing">
  Configure persistence for a self-hosted deployment.
</Card>


# Presentations and slides
Source: https://docs.presenton.ai/general/presentations-and-slides

Learn how outlines, slides, templates, layouts, and editable elements fit together.

Presenton builds a presentation as a sequence of slides. The outline controls the story; the template controls the visual system; each slide combines content with a suitable layout.

<img alt="Diagram showing a presentation made from an outline, template, slides, layouts, and editable elements" />

## The building blocks

| Concept      | What it controls                                        | Change it when…                                  |
| ------------ | ------------------------------------------------------- | ------------------------------------------------ |
| Presentation | The complete deck and slide order                       | The story needs a different sequence             |
| Outline      | The planned message for each section or slide           | An idea is missing, repeated, or misplaced       |
| Template     | Reusable design choices and available layouts           | The deck must follow another brand or style      |
| Layout       | The arrangement of content on one slide                 | The current composition does not fit the message |
| Element      | A text, image, shape, table, chart, or supported object | A specific part of the slide needs correction    |

## Standard and Smart formats

<Tabs>
  <Tab title="Standard">
    Standard presentations use predefined, reusable layouts. Choose this format when consistency and predictable content placement matter. A template provides the layout options used during generation.
  </Tab>

  <Tab title="Smart">
    Smart presentations use a design reference to guide more adaptive slide composition. This format is available in Cloud for workflows that need more visual variation.
  </Tab>
</Tabs>

The current open-source application documents **Standard**. It uses reusable layouts and represents each slide as structured JSON rendered onto a `1280 x 720` editing canvas. Components and nested elements retain their geometry and styling, allowing direct selection, rich-text editing, drag-and-drop movement, transforms, layering, data editing, and targeted AI changes.

## What remains editable

| Object                    | Typical controls                                                                  |
| ------------------------- | --------------------------------------------------------------------------------- |
| Text and lists            | Content, typography, formatting, alignment, position, size, and rotation          |
| Images                    | Source, fit, crop, flip, radius, opacity, position, and size                      |
| Shapes and lines          | Fill, stroke, radius, shadow, opacity, position, and geometry                     |
| Tables                    | Cell content, rows, columns, ordering, and text alignment                         |
| Charts                    | Type, data, series, titles, values, axes, gridlines, labels, colors, and opacity  |
| Components and containers | Position, dimensions, rotation, opacity, layering, padding, alignment, and layout |
| Slides                    | Layout, order, duplication, deletion, and AI-assisted changes                     |

<Tip>
  Fix a story problem in the outline, a deck-wide visual problem in the template, and a local content problem on the slide. Choosing the right level avoids repetitive edits.
</Tip>

<CardGroup>
  <Card title="Work with templates" icon="palette" href="/user-guide/branding-and-design/templates">
    Prepare reusable layouts for branded generation.
  </Card>

  <Card title="Compare availability" icon="table-list" href="/general/feature-availability">
    Check which formats are documented for each mode.
  </Card>
</CardGroup>


# What Presenton does
Source: https://docs.presenton.ai/general/what-presenton-does

See how Presenton turns prompts, documents, and data into editable AI-generated presentations.

Presenton turns source material into an editable slide deck. It handles the repetitive first-draft work while you keep control of the message, design, and final review.

Unlike an image-only slide generator, Presenton builds presentation content that can continue through a normal PowerPoint workflow. The Standard presentation editor in Cloud and open-source Presenton lets you directly edit text, images, shapes, tables, charts, containers, and slide structure before exporting to PPTX or PDF.

## The work Presenton accelerates

| Stage    | Presenton helps with                                                                                                  | You decide                                           |
| -------- | --------------------------------------------------------------------------------------------------------------------- | ---------------------------------------------------- |
| Brief    | Reads a prompt, documents, files, or structured input                                                                 | Audience, goal, and must-keep facts                  |
| Story    | Proposes an outline and slide sequence                                                                                | What belongs, what does not, and what needs emphasis |
| Design   | Applies a selected template and adds supported visuals                                                                | Brand fit and visual quality                         |
| Editing  | Provides a drag-and-drop canvas, rich text and media tools, component controls, data editing, and targeted AI changes | Final wording, accuracy, brand fit, and approval     |
| Delivery | Exports to PPTX or PDF                                                                                                | How and where the deck is shared                     |

## Edit beyond the first draft

The shared Standard editor is a structured slide canvas, not a flat preview. Select a slide, component, or individual element and adjust it without regenerating the entire presentation.

<AccordionGroup>
  <Accordion title="Text and typography" icon="text-size">
    Edit title, subtitle, body, quote, and list content. Choose fonts and font sizes; apply text color, highlight, bold, italic, underline, and hyperlinks; change alignment; and move, resize, or rotate text elements.
  </Accordion>

  <Accordion title="Canvas, components, and layering" icon="objects-align-center-horizontal">
    Drag components freely, reposition them, and control width, height, rotation, and opacity. Resize or rotate with canvas handles, ungroup supported components, duplicate or paste selections, and use **Bring forward**, **Send backward**, **Bring to front**, or **Send to back** to control stacking order.
  </Accordion>

  <Accordion title="Shapes, lines, and containers" icon="shapes">
    Insert and edit rectangles, ellipses, and lines. Control fill, border, radius, stroke width, shadow, opacity, size, and position. Use horizontal, vertical, flex, grid, and container layouts with alignment, padding, background, border, and radius controls.
  </Accordion>

  <Accordion title="Images" icon="image">
    Insert, upload, or replace images; choose fit behavior; crop and reposition the image within its frame; flip horizontally or vertically; and adjust border radius and opacity. Templates can combine images with text or arrange them in reusable grids and layouts.
  </Accordion>

  <Accordion title="Tables and charts" icon="chart-column">
    Insert tables, paste tabular data, edit cells, add or remove rows and columns, move columns, and change text alignment. Create bar, line, area, pie, and doughnut charts; edit or import chart data; manage rows, columns, and series; switch chart types; configure titles, values, axes, gridlines, labels, colors, and opacity; and export chart data as CSV.
  </Accordion>

  <Accordion title="Slides, templates, and AI editing" icon="sparkles">
    Add blank slides, apply template layouts, duplicate or delete slides, and reorder the deck. Build reusable layouts from a PPTX, generate presentations from those templates, then use the context-aware assistant for selected-slide or selected-component edits and targeted follow-up responses.
  </Accordion>
</AccordionGroup>

<Note>
  These capabilities describe the Standard editor shared by Cloud and open-source Presenton. The controls you see change according to the selected slide element.
</Note>

## Common ways to use it

<CardGroup>
  <Card title="One-off presentations" icon="presentation-screen">
    Create a pitch, lesson, proposal, or internal update from a clear brief.
  </Card>

  <Card title="Document summaries" icon="file-lines">
    Turn relevant source material into a shorter visual narrative.
  </Card>

  <Card title="Repeatable reports" icon="chart-column">
    Generate recurring decks from structured input and a stable template.
  </Card>

  <Card title="Product integrations" icon="plug">
    Add presentation generation to an application or automated workflow.
  </Card>
</CardGroup>

## Where it fits

Presenton can be used through its browser interface for hands-on creation, through the self-hosted MCP server for an AI-tool workflow, or through REST APIs for application-driven generation. The self-hosted MCP surface exposes synchronous generation, asynchronous generation, and task-status checking; it is disabled in the Electron desktop app.

## Set the right expectation

Presenton is strongest when the source has a clear goal and the template fits the story. It does not guarantee that a claim is true, that every source detail is included, or that a generated slide is ready to present without review.

<Tip>
  Spend time on the outline before generating slides. Fixing the story early is faster than repairing every slide later.
</Tip>

<Card title="Follow the complete workflow" icon="diagram-project" href="/general/how-presenton-works">
  See where to provide direction, review output, and make corrections.
</Card>


# Deploy with Docker
Source: https://docs.presenton.ai/hosting/docker

Self-host Presenton from a published GHCR image or build it directly from the GitHub source.

Presenton can be self-hosted in two ways. Most users should run a published image from the GitHub Container Registry (GHCR). Build from source when you need to inspect, modify, or test the application code.

<CardGroup>
  <Card title="Run a GHCR release" icon="box">
    The recommended path for production. It starts quickly, requires no local build, and uses a versioned image published by the Presenton team.
  </Card>

  <Card title="Build from GitHub source" icon="github">
    The flexible path for development and customization. Clone the repository and let Docker Compose build the application on your server.
  </Card>
</CardGroup>

|                    | GHCR release                                  | Build from source                                 |
| ------------------ | --------------------------------------------- | ------------------------------------------------- |
| Best for           | Production and most self-hosted installations | Development, customization, and testing           |
| Application source | Prebuilt and published by Presenton           | A Git branch, tag, or commit you choose           |
| Startup time       | Fast; Docker only downloads the image         | Slower initially; Docker builds the image locally |
| Updates            | Pull a newer published image                  | Pull source changes and rebuild                   |

## Option 1: Run a published GHCR release

This is the most stable and straightforward way to self-host Presenton. The image already contains the frontend, API, export tools, and runtime dependencies, so the host only needs Docker.

The examples below use `latest` so they continue to follow the newest published image without needing a version-specific edit. Browse the [published image versions](https://github.com/presenton/presenton/pkgs/container/presenton) when you need to select a fixed release or image digest instead.

<Tabs>
  <Tab title="Linux and macOS">
    ```bash theme={null}
    mkdir -p app_data
    ```

    Then start Presenton:

    ```bash theme={null}
    docker run --detach \
      --name presenton \
      --restart unless-stopped \
      --publish 5001:80 \
      --volume "$(pwd)/app_data:/app_data" \
      ghcr.io/presenton/presenton:latest
    ```
  </Tab>

  <Tab title="Windows PowerShell">
    ```powershell theme={null}
    New-Item -ItemType Directory -Force app_data
    ```

    Then start Presenton:

    ```powershell theme={null}
    docker run --detach `
      --name presenton `
      --restart unless-stopped `
      --publish 5001:80 `
      --volume "${PWD}\app_data:/app_data" `
      ghcr.io/presenton/presenton:latest
    ```
  </Tab>
</Tabs>

Open [http://localhost:5001](http://localhost:5001) after the container starts. The first port in `5001:80` is the port on your host and can be changed; container port `80` serves the web app, REST API, and `/mcp`.

<Tip>
  Use an explicit version tag in production so upgrades happen when you choose. Use `latest` when automatically following the newest published release is more important than repeatability.
</Tip>

### Configure the release image

Pass settings with `--env-file` to keep the `docker run` command readable:

```dotenv theme={null}
# .env
AUTH_USERNAME=admin
AUTH_PASSWORD=replace-with-a-long-password
LLM=openai
OPENAI_API_KEY=replace-with-your-key
OPENAI_MODEL=gpt-4.1
CAN_CHANGE_KEYS=false
```

Then add `--env-file .env` before the image name:

```bash theme={null}
docker run --detach \
  --name presenton \
  --restart unless-stopped \
  --publish 5001:80 \
  --volume "$(pwd)/app_data:/app_data" \
  --env-file .env \
  ghcr.io/presenton/presenton:latest
```

See [Environment variables](/hosting/environment-variables) for all supported providers and runtime settings.

### Update a GHCR deployment

Pull the new image before replacing the container. Keep the same `app_data` directory and startup options.

```bash theme={null}
docker pull ghcr.io/presenton/presenton:latest
```

Stop the existing container:

```bash theme={null}
docker stop presenton
```

Remove the stopped container:

```bash theme={null}
docker rm presenton
```

Run the container again with the same volume and environment options. When you use `latest`, pulling and recreating the container moves it to the newest published image. When you use a fixed version or digest, update it in both the `docker pull` and `docker run` commands.

## Option 2: Build from the GitHub source

Choose this path when you want to change Presenton, review the code before deployment, test unreleased work, or build a specific branch or commit. You need Git, Docker Engine, and the Docker Compose plugin.

<Steps>
  <Step title="Clone the repository">
    ```bash theme={null}
    git clone https://github.com/presenton/presenton.git
    ```

    Open the cloned repository:

    ```bash theme={null}
    cd presenton
    ```
  </Step>

  <Step title="Choose the source revision">
    A fresh clone uses `main`, which contains the newest source. For a repeatable build, check out a Git tag or commit that exists in the repository before continuing.

    Optionally, list the available release tags:

    ```bash theme={null}
    git tag --list
    ```

    To pin a revision, replace `TAG_OR_COMMIT` with the tag or commit you want:

    ```bash theme={null}
    git checkout TAG_OR_COMMIT
    ```
  </Step>

  <Step title="Add your configuration">
    Create `.env` beside `docker-compose.yml`. Compose reads this file and forwards the supported values to Presenton.

    ```dotenv theme={null}
    PRESENTON_HTTP_HOST_PORT=5001
    AUTH_USERNAME=admin
    AUTH_PASSWORD=replace-with-a-long-password
    LLM=openai
    OPENAI_API_KEY=replace-with-your-key
    OPENAI_MODEL=gpt-4.1
    CAN_CHANGE_KEYS=false
    ```
  </Step>

  <Step title="Build and start Presenton">
    ```bash theme={null}
    docker compose up --build --detach production
    ```

    Compose builds the repository's production `Dockerfile`, starts the container, and mounts `./app_data` at `/app_data`.
  </Step>
</Steps>

Open [http://localhost:5001](http://localhost:5001) when the build finishes.

<Note>
  The `main` branch can contain changes that have not reached a published container release. For a more predictable source build, check out a release tag or pin a commit before building.
</Note>

### Update a source build

If you follow `main`, pull the newest commits and rebuild:

```bash theme={null}
git pull --ff-only
```

Then rebuild the deployment:

```bash theme={null}
docker compose up --build --detach production
```

If you pin a tag or commit, fetch the available revisions, check out the one you want, and rebuild:

```bash theme={null}
git fetch --tags
```

Check out the new tag or commit:

```bash theme={null}
git checkout TAG_OR_COMMIT
```

Then rebuild the deployment:

```bash theme={null}
docker compose up --build --detach production
```

The repository also provides `production-gpu`, `development`, and `development-gpu` services. Use `production` for a normal hosted instance. Use `production-gpu` only after installing the NVIDIA Container Toolkit and confirming that Docker can access the GPU.

## Persistence

Both deployment paths store persistent state in `/app_data` inside the container:

* The GHCR commands mount the local `./app_data` directory explicitly.
* The repository's Compose service creates the same mount automatically.

<Warning>
  Never replace or upgrade the container without preserving `/app_data`. It contains presentations, uploads, templates, settings, authentication state, the default database, exports, and local memory.
</Warning>

Back up this directory before upgrades. See [Backups and recovery](/hosting/backups-and-recovery) for a complete backup and restore workflow.

## Ports and networking

| Mapping     | Use                               |
| ----------- | --------------------------------- |
| `5001:80`   | Browser, REST API, and MCP        |
| `1455:1455` | ChatGPT/Codex OAuth callback only |

`localhost` inside a container refers to the container itself. Reach another Compose service by its service name, or reach a service on the host through a supported host gateway such as `host.docker.internal`.

## Operate and verify

For a GHCR container:

```bash theme={null}
docker logs --follow presenton
```

Stop the container:

```bash theme={null}
docker stop presenton
```

Start it again:

```bash theme={null}
docker start presenton
```

Check its status:

```bash theme={null}
docker ps --filter name=presenton
```

For a source deployment:

```bash theme={null}
docker compose logs --follow production
```

Stop the service:

```bash theme={null}
docker compose stop production
```

Start it again:

```bash theme={null}
docker compose start production
```

Check its status:

```bash theme={null}
docker compose ps
```

After deployment, generate a small presentation, restart Presenton, and confirm that the presentation remains available. Then test export and any REST API or MCP integration you plan to expose.


# Enterprise support
Source: https://docs.presenton.ai/hosting/enterprise

Discuss custom identity, access, deployment, integration, and support requirements with Presenton.

Presenton Enterprise helps organizations extend a self-hosted deployment around their security, identity, infrastructure, and workflow requirements.

## Capabilities to discuss

<CardGroup>
  <Card title="RBAC and permissions" icon="users-gear">
    Define role-based access and permissions for administrators, creators, reviewers, and other teams.
  </Card>

  <Card title="OAuth and SSO" icon="key">
    Integrate OAuth 2.0 or OpenID Connect with your organization's identity provider.
  </Card>

  <Card title="Private deployment" icon="building-shield">
    Plan on-premise, private-cloud, hybrid, or air-gapped deployment requirements.
  </Card>

  <Card title="Audit and compliance" icon="clipboard-check">
    Discuss auditability, data handling, network controls, and compliance requirements.
  </Card>

  <Card title="Custom integrations" icon="puzzle-piece">
    Connect internal data sources, workflows, templates, authentication, and other systems.
  </Card>

  <Card title="Onboarding and support" icon="life-ring">
    Scope implementation help, onboarding, priority support, and service-level requirements.
  </Card>
</CardGroup>

Enterprise capabilities are scoped to your organization and deployment. Contact the team to confirm availability, implementation details, and commercial terms.

<Card title="Contact sales" icon="envelope" href="https://presenton.ai/contact-sales">
  Tell us about your team, deployment, security requirements, and the capabilities you need.
</Card>


# Environment variables
Source: https://docs.presenton.ai/hosting/environment-variables

Reference supported self-hosted settings by deployment concern.

Use environment variables for repeatable deployments and centrally managed secrets. The in-app Settings page is convenient for personal instances; environment variables are better for servers, automation, and locked-down provider credentials.

## Runtime and access

| Variable                     | Default      | Purpose                                                                    | Sensitive |
| ---------------------------- | ------------ | -------------------------------------------------------------------------- | --------- |
| `PRESENTON_HTTP_HOST_PORT`   | `5001`       | Compose host port mapped to container port `80`                            | No        |
| `CAN_CHANGE_KEYS`            | unset        | Set `false` to prevent users changing administrator-supplied provider keys | No        |
| `AUTH_USERNAME`              | unset        | Preseed or recover the primary administrator account                       | No        |
| `AUTH_PASSWORD`              | unset        | Password used only to initialize or explicitly rotate credentials          | Yes       |
| `AUTH_OVERRIDE_FROM_ENV`     | `false`      | Apply a one-time credential rotation from environment values               | No        |
| `RESET_AUTH`                 | `false`      | Remove configured authentication during a recovery boot                    | No        |
| `DATABASE_URL`               | local SQLite | External PostgreSQL or MySQL connection URL                                | Yes       |
| `DISABLE_ANONYMOUS_TRACKING` | `false`      | Disable anonymous product telemetry                                        | No        |

## Text providers

Set `LLM` to the provider identifier, then configure that provider's model and credentials.

| Provider          | Required or common variables                                                                                        |
| ----------------- | ------------------------------------------------------------------------------------------------------------------- |
| Presenton Cloud   | Connect as the local administrator in onboarding or Settings; the application stores `LLM=presenton` after approval |
| OpenAI            | `LLM=openai`, `OPENAI_API_KEY`, `OPENAI_MODEL`                                                                      |
| Google            | `LLM=google`, `GOOGLE_API_KEY`, `GOOGLE_MODEL`                                                                      |
| Anthropic         | `LLM=anthropic`, `ANTHROPIC_API_KEY`, `ANTHROPIC_MODEL`                                                             |
| Ollama            | `LLM=ollama`, `OLLAMA_URL`, `OLLAMA_MODEL`                                                                          |
| LM Studio         | `LLM=lmstudio`, `LMSTUDIO_BASE_URL`, `LMSTUDIO_MODEL`                                                               |
| OpenAI-compatible | `LLM=custom`, `CUSTOM_LLM_URL`, `CUSTOM_LLM_API_KEY`, `CUSTOM_MODEL`                                                |
| Azure OpenAI      | `LLM=azure` plus endpoint, API version, model/deployment, and credentials                                           |
| Amazon Bedrock    | `LLM=bedrock`, region, model, and one supported AWS authentication method                                           |
| LiteLLM           | `LLM=litellm`, `LITELLM_BASE_URL`, `LITELLM_MODEL`, optional API key                                                |

<Card title="Provider details" icon="microchip" href="/self-hosted/core-concepts/providers">
  Review supported roles, local-versus-hosted data flow, and provider-specific guides.
</Card>

## Images and search

| Variable                                            | Purpose                                               |
| --------------------------------------------------- | ----------------------------------------------------- |
| `IMAGE_PROVIDER`                                    | Select stock or generated-image provider              |
| `PEXELS_API_KEY`, `PIXABAY_API_KEY`                 | Stock-image credentials                               |
| `DISABLE_IMAGE_GENERATION`                          | Disable presentation image generation                 |
| `ENABLE_PARALLEL_IMAGE_GENERATION`                  | Control concurrent image work                         |
| `WEB_GROUNDING`                                     | Enable web context by default                         |
| `WEB_SEARCH_PROVIDER`                               | Select `auto`, native search, SearXNG, Tavily, or Exa |
| `WEB_SEARCH_MAX_RESULTS`                            | Limit external results added to model context         |
| `SEARXNG_BASE_URL`, `TAVILY_API_KEY`, `EXA_API_KEY` | Search-provider connection details                    |

## Processing and memory

| Variable                | Default                           | Purpose                                         |
| ----------------------- | --------------------------------- | ----------------------------------------------- |
| `LITEPARSE_DPI`         | `120`                             | Rendering resolution during document extraction |
| `LITEPARSE_NUM_WORKERS` | `1`                               | Document-processing workers                     |
| `MEM0_ENABLED`          | `true`                            | Enable presentation-scoped memory               |
| `MEM0_DIR`              | `/app_data/mem0`                  | Memory storage root                             |
| `MEM0_LLM_MODEL`        | Ollama model or `llama3.1:latest` | Memory extraction model                         |
| `MEM0_LLM_BASE_URL`     | Ollama URL or host gateway        | Compatible model endpoint                       |
| `MEM0_EMBEDDER_MODEL`   | `BAAI/bge-small-en-v1.5`          | Local embedding model                           |

## Apply changes safely

* Keep secrets out of source control and shell history.
* Change one provider role at a time and run a short generation afterward.
* Restart or replace the container after environment changes.
* Back up `/app_data` and an external database before storage or migration changes.
* Treat empty values differently from deliberate `false` values.


# Connect an MCP client
Source: https://docs.presenton.ai/hosting/mcp

Authenticate Presenton's MCP server and connect local, remote, or multiple self-hosted instances.

The built-in Model Context Protocol server lets a compatible AI client invoke Presenton presentation workflows. MCP is available in the self-hosted web deployment at `/mcp`; it is disabled in the Electron desktop app.

## Before you start

* Run Presenton with Docker, Compose, or another web deployment.
* Confirm browser generation works.
* Configure the primary administrator for any shared or remote instance.
* Confirm your client supports a remote HTTP MCP server and custom headers.

## 1. Start an authenticated instance

```bash theme={null}
docker run -it --name presenton \
  --publish 5001:80 \
  --env AUTH_USERNAME=admin \
  --env AUTH_PASSWORD=replace-with-a-long-password \
  --volume "./app_data:/app_data" \
  ghcr.io/presenton/presenton:latest
```

Open [http://localhost:5001](http://localhost:5001), sign in, and create a small test presentation before continuing.

## 2. Generate an API key

Sign in as the primary administrator, open **Admin → API keys**, select **Generate key**, and copy the new `sk-presenton-...` value. The key is shown only when it is created.

<Warning>
  A Presenton API key grants API and MCP access. Do not commit it to a repository, paste it into support tickets, or expose it in screenshots.
</Warning>

## 3. Configure the MCP client

Configuration formats vary by client. The following examples use the structure from the Presenton README; adapt the outer file location and environment-variable syntax to your client.

### Example A: local authenticated server

```json theme={null}
{
  "mcpServers": {
    "presenton": {
      "url": "http://localhost:5001/mcp",
      "headers": {
        "Authorization": "Bearer sk-presenton-REPLACE_WITH_YOUR_KEY"
      }
    }
  }
}
```

### Example B: remote HTTPS server

```json theme={null}
{
  "mcpServers": {
    "presenton-production": {
      "url": "https://presentations.example.com/mcp",
      "headers": {
        "Authorization": "Bearer sk-presenton-REPLACE_WITH_YOUR_KEY"
      }
    }
  }
}
```

Use HTTPS for any connection that leaves the local machine. The reverse proxy must forward the `Authorization` header and support the connection behavior required by your MCP client.

### Example C: local server without configured auth

For an isolated development instance where authentication has not been configured, omit the header:

```json theme={null}
{
  "mcpServers": {
    "presenton-local": {
      "url": "http://localhost:5001/mcp"
    }
  }
}
```

Do not use an unauthenticated configuration on a publicly reachable instance.

### Example D: development and production instances

```json theme={null}
{
  "mcpServers": {
    "presenton-local": {
      "url": "http://localhost:5001/mcp",
      "headers": {
        "Authorization": "Bearer sk-presenton-LOCAL_KEY"
      }
    },
    "presenton-production": {
      "url": "https://presentations.example.com/mcp",
      "headers": {
        "Authorization": "Bearer sk-presenton-PRODUCTION_KEY"
      }
    }
  }
}
```

Give each instance a clear name so users know where uploaded documents and generated presentations will be stored.

## 4. Restart and verify the client

<Steps>
  <Step title="Reload MCP configuration">
    Restart the client or use its MCP reload action so it reads the new server entry.
  </Step>

  <Step title="Check discovery">
    Confirm the client reports the Presenton server as connected and displays its available presentation tools.
  </Step>

  <Step title="Run a small request">
    Ask the client to create a short two-slide presentation about a harmless test topic.
  </Step>

  <Step title="Review in Presenton">
    Open the returned edit URL, inspect the slides, and confirm the presentation appears in the correct instance.
  </Step>
</Steps>

## Key rotation and recovery

Revoke a key from **Admin → API keys** and generate a replacement whenever a client no longer needs access or a key may have been exposed. Credential override or administrator recovery invalidates existing browser sessions and API keys.

If a client starts returning unauthorized errors:

1. Confirm the Presenton URL and `/mcp` path.
2. Sign in as the primary administrator.
3. Confirm the key is still active under **Admin → API keys**, or generate a replacement.
4. Replace the old key in the client configuration.
5. Restart or reload the client.

## Secure a remote MCP deployment

* Use HTTPS and a trusted certificate.
* Keep Presenton authentication enabled.
* Restrict network access to expected users and clients.
* Store API keys in the client's secret store when supported.
* Revoke and replace keys after suspected exposure.
* Protect `/app_data`, because MCP-created presentations and uploads are stored there.
* Review generated presentations before publishing or exporting them.

<AccordionGroup>
  <Accordion title="The client cannot find Presenton tools">
    Confirm that it supports remote HTTP MCP, that the URL ends in `/mcp`, and that configuration was reloaded. The desktop app does not expose MCP.
  </Accordion>

  <Accordion title="The server returns 401 or unauthorized">
    Confirm the API key is active and the header is exactly `Authorization: Bearer sk-presenton-REPLACE_WITH_YOUR_KEY`.
  </Accordion>

  <Accordion title="It works locally but not through a reverse proxy">
    Verify HTTPS routing to container port `80`, forwarding of the `Authorization` header, and the proxy's timeout or buffering behavior for remote MCP connections.
  </Accordion>

  <Accordion title="Keys stopped working after a deployment change">
    Administrator credential override or recovery invalidates API keys. Sign in again, generate a new key, and update the MCP client.
  </Accordion>
</AccordionGroup>

<Check>
  The MCP client discovers Presenton's tools, creates a test presentation, and returns a result that opens in the intended self-hosted instance.
</Check>


# Presentation memory
Source: https://docs.presenton.ai/hosting/memory

Configure, persist, size, and troubleshoot self-hosted presentation memory.

Presentation memory helps AI-assisted editing retain relevant context across changes to the same presentation. Self-hosted Presenton uses Mem0 OSS with local vector and history storage under `/app_data` by default.

## Default configuration

```dotenv theme={null}
MEM0_ENABLED=true
MEM0_DIR=/app_data/mem0
MEM0_EMBEDDER_PROVIDER=fastembed
MEM0_EMBEDDER_MODEL=BAAI/bge-small-en-v1.5
MEM0_EMBEDDING_DIMS=384
MEM0_SPACY_MODEL=en_core_web_sm
MEM0_REQUIRE_SPACY_MODEL=true
```

The official container includes the required spaCy model. The embedding model may be downloaded on first use, so restricted or offline deployments should pre-populate the required cache.

## Memory model

Mem0 also needs an OpenAI-compatible text endpoint for extracting useful memories:

```dotenv theme={null}
MEM0_LLM_MODEL=llama3.1:latest
MEM0_LLM_API_KEY=ollama
MEM0_LLM_BASE_URL=http://host.docker.internal:11434
```

The memory model can differ from the model that creates presentations. Confirm that a container can reach the configured URL; `localhost` inside Docker does not refer to the host.

## Persistence and privacy

* Keep `MEM0_DIR` inside the persistent `/app_data` mount.
* Include memory data in backups and protect it like presentation content.
* Hosted memory-model endpoints receive the context sent for memory extraction.
* Set `MEM0_ENABLED=false` when iterative memory is unnecessary or the workflow must avoid that processing.

## Troubleshoot

Check application logs for missing spaCy or embedding models, unreachable endpoints, invalid dimensions, and filesystem permission errors. After changing the embedding model or dimensions, use a clean compatible collection rather than mixing incompatible vectors.


# One-click cloud deployment
Source: https://docs.presenton.ai/hosting/one-click-deployments

Deploy Presenton to Railway or DigitalOcean and finish the required production configuration.

One-click templates are the fastest route to a remotely accessible instance. The platform runs the container, but you still own credentials, persistent storage, HTTPS exposure, backups, and upgrades.

<CardGroup>
  <Card title="Deploy to Railway" icon="train" href="https://railway.com/deploy/presenton-ai-presentations">
    Create a service from the maintained Railway template.
  </Card>

  <Card title="Deploy to DigitalOcean" icon="digital-ocean" href="https://cloud.digitalocean.com/apps/new?repo=https://github.com/presenton/presenton/tree/main">
    Create an App Platform deployment from the Presenton repository.
  </Card>
</CardGroup>

## Before deploying

* Choose a region allowed by your data-handling requirements.
* Prepare credentials for one text provider and, optionally, an image or search provider.
* Decide whether the service will be private or internet-facing.
* Plan a persistent disk mounted at `/app_data`.

## Required platform configuration

1. Route the platform's HTTPS endpoint to container port `80`.
2. Mount durable storage at `/app_data`; ephemeral storage loses application data during replacement or redeployment.
3. Store provider keys and `AUTH_PASSWORD` in the platform's secret manager.
4. Set `AUTH_USERNAME`, `AUTH_PASSWORD`, and `CAN_CHANGE_KEYS=false` before sharing the URL.
5. Configure restart behavior and monitor available disk space.

<Warning>
  A successful deployment without a persistent `/app_data` disk is not production-ready. Test persistence by creating a presentation, restarting or redeploying the service, and confirming that it remains available.
</Warning>

## Verify the deployment

* Open the generated HTTPS URL and sign in.
* Generate and export a short presentation.
* Confirm the selected provider can be reached from the platform.
* Test the REST API and `/mcp` only if they will be used.
* Create a backup and perform a test restore before storing important content.

For another container platform, apply the same contract: container port `80`, durable `/app_data`, protected secrets, authentication, HTTPS, monitoring, and backups.


# Self Host Presenton in Five Minutes
Source: https://docs.presenton.ai/hosting/overview

Start a persistent Presenton instance with Docker and explore support for custom enterprise requirements.

This guide gets Presenton running locally with Docker, persistent storage, and a text provider. It also explains what the deployment includes and where to go for custom enterprise capabilities.

## Before you start

You need:

* [Docker](https://docs.docker.com/get-started/get-docker/)
* Credentials for a supported text provider, or a reachable local model
* Port `5001` available on your computer

<Note>
  Presenton Cloud needs no hosting setup. Use this guide only when you want to run Presenton in infrastructure you control.
</Note>

<Warning>
  Self-hosting the application does not make every workflow local. Configured hosted AI, image, or search providers receive the content sent to them. Choose local providers and disable external integrations when content must remain inside your network.
</Warning>

## 1. Start Presenton

<Tabs>
  <Tab title="Linux and macOS">
    ```bash theme={null}
    mkdir -p app_data
    ```

    Then start Presenton:

    ```bash theme={null}
    docker run --detach --name presenton \
      --publish 5001:80 \
      --volume "./app_data:/app_data" \
      ghcr.io/presenton/presenton:latest
    ```
  </Tab>

  <Tab title="Windows PowerShell">
    ```powershell theme={null}
    New-Item -ItemType Directory -Force app_data
    ```

    Then start Presenton:

    ```powershell theme={null}
    docker run --detach --name presenton `
      --publish 5001:80 `
      --volume "${PWD}\app_data:/app_data" `
      ghcr.io/presenton/presenton:latest
    ```
  </Tab>
</Tabs>

The host folder is mounted at `/app_data` so presentations and settings survive container replacement.

## 2. Open Presenton

Visit [http://localhost:5001](http://localhost:5001). If the page does not load, check the container:

```bash theme={null}
docker ps --filter name=presenton
```

If the container is running but the page still does not load, inspect its recent logs:

```bash theme={null}
docker logs --tail 100 presenton
```

## 3. Connect a text provider

Follow the first-run Settings flow and choose a provider. In `v0.9.7-beta` and later, the local administrator can connect a Presenton account with the displayed device code and use Presenton Cloud as the installation-wide generation provider. This provider connection is separate from local application sign-in.

For another hosted-provider setup, enter its API key and supported model in the application.

To keep administrator-supplied credentials out of the UI, restart the container with environment variables instead:

```bash theme={null}
docker stop presenton
```

Remove the stopped container:

```bash theme={null}
docker rm presenton
```

Start it again with your provider settings:

```bash theme={null}
docker run --detach --name presenton \
  --publish 5001:80 \
  --env LLM=openai \
  --env OPENAI_API_KEY="YOUR_API_KEY" \
  --env OPENAI_MODEL=gpt-4.1 \
  --env CAN_CHANGE_KEYS=false \
  --volume "./app_data:/app_data" \
  ghcr.io/presenton/presenton:latest
```

<Warning>
  Do not paste real keys into source files or commit a `.env` file. Use your deployment platform's secret manager for a remote instance.
</Warning>

## 4. Generate and persist a test deck

Create a short two- or three-slide presentation. Restart the container with `docker restart presenton`, reopen the dashboard, and confirm the deck remains available.

<Check>
  The application loads, a text provider generates a deck, export completes, and the deck remains after restart.
</Check>

## What you are self-hosting

The container runs the Presenton web application, REST API, and MCP server. A self-hosted deployment includes:

* Browser-based presentation generation, editing, templates, and export
* Persistent presentations, uploads, generated assets, settings, and local memory under `/app_data`
* Configurable text, image, search, and database providers
* Multi-user authentication with private workspaces and administrator-managed access
* A built-in MCP endpoint for compatible clients
* Docker and GPU-capable Compose services

## Why self-host

<CardGroup>
  <Card title="Control deployment and data" icon="database">
    Choose the network, persistent storage, database, backup policy, and geographic location.
  </Card>

  <Card title="Bring your own providers" icon="microchip">
    Combine hosted or local text, image, and search providers without coupling them to one vendor.
  </Card>

  <Card title="Automate presentations" icon="brackets-curly">
    Use the built-in REST API and remote HTTP MCP server from your own tools.
  </Card>

  <Card title="Customize the source" icon="code">
    Inspect and modify the Apache-2.0-licensed application for your environment.
  </Card>
</CardGroup>

## Enterprise support

<CardGroup>
  <Card title="Role-based access control" icon="users-gear">
    Scope custom roles and permissions for teams with different responsibilities.
  </Card>

  <Card title="OAuth and SSO" icon="key">
    Discuss OAuth, OpenID Connect, and identity-provider integration for your organization.
  </Card>

  <Card title="Custom deployment" icon="building-shield">
    Plan private, on-premise, air-gapped, or hybrid deployments around your requirements.
  </Card>

  <Card title="Custom integrations" icon="puzzle-piece">
    Connect Presenton to internal systems, workflows, templates, and data sources.
  </Card>
</CardGroup>

Need capabilities beyond the open-source self-hosted deployment? [Contact the Presenton enterprise team](https://presenton.ai/contact-sales) to discuss RBAC, OAuth and SSO, custom integrations, deployment assistance, onboarding, and support.

<Card title="Explore enterprise support" icon="building" href="/hosting/enterprise">
  Review common enterprise requirements and contact the team to scope a solution.
</Card>


# Get a Pexels API key
Source: https://docs.presenton.ai/hosting/provider-api-keys/get-pexels-api-key

Sign in to Pexels, open the Image & Video API section, and copy your API key for use in Presenton or other integrations.

Get your Pexels API key from your [Pexels](https://pexels.com) account when you need image access for Presenton or another integration that uses the Pexels API.

## Before you start

* Make sure you can sign in to your Pexels account.
* Use the account that should own the API key.

<Warning>
  Treat the API key like a secret. Do not share it publicly or paste it into unsecured places.
</Warning>

## Get a [Pexels](https://pexels.com) API key

<Steps>
  <Step title="Open the Pexels account menu">
    On the Pexels website, open the account menu in the top-right corner and select **Log in** if you are not already signed in.

    <Frame>
      <img alt="Pexels home page with the account menu open and the Log in option visible" />
    </Frame>
  </Step>

  <Step title="Sign in to your Pexels account">
    Log in with your email or one of the available sign-in providers.

    <Frame>
      <img alt="Pexels login page with email and password fields and sign-in options" />
    </Frame>
  </Step>

  <Step title="Open the Image & Video API section">
    After signing in, open the account menu again and select **Image & Video API**.

    <Frame>
      <img alt="Pexels account page with the account menu open and the Image and Video API option highlighted" />
    </Frame>
  </Step>

  <Step title="Open your API key page">
    On the Pexels API page, click **Your API Key**.

    <Frame>
      <img alt="Pexels API page with the Your API Key button visible" />
    </Frame>
  </Step>

  <Step title="Copy the API key">
    On the **Your API Key** page, use the copy button to copy the key.

    <Frame>
      <img alt="Pexels Your API Key page showing the API key field and a copy icon" />
    </Frame>
  </Step>
</Steps>

## Verify the result

<Check>
  You can copy the Pexels API key from your account and paste it into the place where the integration asks for it.
</Check>


# Get a Pixabay API key
Source: https://docs.presenton.ai/hosting/provider-api-keys/get-pixabay-api-key

Sign in to Pixabay, open the API area, and find your API key in the API documentation reference section.

Get your Pixabay API key from the Pixabay API documentation when you need to connect Pixabay to Presenton or another image integration.

## Before you start

* Make sure you can sign in to your [Pixabay](https://pixabay.com) account.
* Use the account that should own the API access.

<Warning>
  Treat the API key like a secret. Do not share it publicly or include it in unsecured documents or screenshots.
</Warning>

## Get a [Pixabay](https://pixabay.com) API key

<Steps>
  <Step title="Open Pixabay and sign in">
    On the Pixabay website, click **Log in** and sign in to your account if you are not already logged in.

    <Frame>
      <img alt="Pixabay home page with the Log in button visible in the top-right corner" />
    </Frame>
  </Step>

  <Step title="Open the Pixabay API page">
    After signing in, click on **Explore** and open the site navigation menu and select **API**.

    <Frame>
      <img alt="Pixabay navigation menu open with the API link visible in the About column" />
    </Frame>
  </Step>

  <Step title="Open the API documentation">
    On the Pixabay Developer API page, click **View API documentation**.

    <Frame>
      <img alt="Pixabay Developer API page with the View API documentation button visible" />
    </Frame>
  </Step>

  <Step title="Scroll to the API reference and find the key parameter">
    In the documentation page, scroll down to the API reference section, then look for the **Search Images** endpoint and the required `key` parameter.

    <Frame>
      <img alt="Pixabay API documentation scrolled to the Search Images reference showing the required key parameter and API key value" />
    </Frame>
  </Step>
</Steps>

<Note>
  The API key reference is not at the top of the documentation page. You need to scroll down to the API reference area to reach the `key` field.
</Note>

## Verify the result

<Check>
  You can locate your Pixabay API key in the API documentation reference and use it where the integration asks for the key value.
</Check>


# Configure Amazon Bedrock
Source: https://docs.presenton.ai/hosting/providers/amazon-bedrock

Connect Presenton to Amazon Bedrock with an API key, AWS credentials, a model ID, or an inference profile.

Presenton uses Amazon Bedrock's Converse API for presentation generation, editing, and AI chat. The value you configure as the model is passed to Bedrock as `modelId`.

## Before you start

You need:

* Bedrock model access in the AWS account and region you will use.
* A standard model ID or inference profile ARN.
* Either a Bedrock API key or AWS credentials with invoke permissions.
* A running self-hosted Presenton instance.

## 1. Choose the model reference

Use one of these formats:

| Model reference       | When to use                                                        | Example                                                                                      |
| --------------------- | ------------------------------------------------------------------ | -------------------------------------------------------------------------------------------- |
| On-demand model ID    | The model supports on-demand invocation                            | `us.anthropic.claude-3-5-haiku-20241022-v1:0`                                                |
| Inference profile ARN | The model requires a provisioned or cross-region inference profile | `arn:aws:bedrock:us-east-1:YOUR_ACCOUNT_ID:inference-profile/us.anthropic.claude-sonnet-4-6` |

Some newer models do not accept a plain model ID for on-demand throughput. Copy the full inference profile ARN from the Bedrock console when AWS requires one.

## 2. Choose one authentication method

<Tabs>
  <Tab title="Bedrock API key">
    ```dotenv theme={null}
    LLM=bedrock
    BEDROCK_REGION=us-east-1
    BEDROCK_MODEL=us.anthropic.claude-3-5-haiku-20241022-v1:0
    BEDROCK_API_KEY=replace-with-your-key
    ```
  </Tab>

  <Tab title="AWS access keys">
    ```dotenv theme={null}
    LLM=bedrock
    BEDROCK_REGION=us-east-1
    BEDROCK_MODEL=us.anthropic.claude-3-5-haiku-20241022-v1:0
    BEDROCK_AWS_ACCESS_KEY_ID=replace-with-your-access-key
    BEDROCK_AWS_SECRET_ACCESS_KEY=replace-with-your-secret
    ```
  </Tab>

  <Tab title="Temporary credentials">
    ```dotenv theme={null}
    LLM=bedrock
    BEDROCK_REGION=us-east-1
    BEDROCK_MODEL=us.anthropic.claude-3-5-haiku-20241022-v1:0
    BEDROCK_AWS_ACCESS_KEY_ID=replace-with-your-access-key
    BEDROCK_AWS_SECRET_ACCESS_KEY=replace-with-your-secret
    BEDROCK_AWS_SESSION_TOKEN=replace-with-your-session-token
    ```
  </Tab>
</Tabs>

Use only one primary authentication path. Do not combine `BEDROCK_API_KEY` with explicit AWS access keys.

For local development, `BEDROCK_PROFILE_NAME` can select a named profile from `~/.aws/credentials`; ensure the credentials file is available to the process or container.

## 3. Grant IAM permissions

The IAM user or role needs permission to invoke the configured model or inference profile:

```json theme={null}
{
  "Version": "2012-10-17",
  "Statement": [
    {
      "Effect": "Allow",
      "Action": [
        "bedrock:InvokeModel",
        "bedrock:InvokeModelWithResponseStream"
      ],
      "Resource": "arn:aws:bedrock:us-east-1:YOUR_ACCOUNT_ID:inference-profile/*"
    }
  ]
}
```

Scope `Resource` to the specific models or inference profiles required by your organization. Also enable model access in the Bedrock console for the foundation model behind the selected profile.

## 4. Start Presenton

<Tabs>
  <Tab title="On-demand model">
    ```bash theme={null}
    docker run -it --name presenton \
      --publish 5001:80 \
      --env LLM=bedrock \
      --env BEDROCK_REGION=us-east-1 \
      --env BEDROCK_AWS_ACCESS_KEY_ID=YOUR_ACCESS_KEY_ID \
      --env BEDROCK_AWS_SECRET_ACCESS_KEY=YOUR_SECRET_ACCESS_KEY \
      --env BEDROCK_MODEL=us.anthropic.claude-3-5-haiku-20241022-v1:0 \
      --env CAN_CHANGE_KEYS=false \
      --volume "./app_data:/app_data" \
      ghcr.io/presenton/presenton:latest
    ```
  </Tab>

  <Tab title="Inference profile">
    ```bash theme={null}
    docker run -it --name presenton \
      --publish 5001:80 \
      --env LLM=bedrock \
      --env BEDROCK_REGION=us-east-1 \
      --env BEDROCK_AWS_ACCESS_KEY_ID=YOUR_ACCESS_KEY_ID \
      --env BEDROCK_AWS_SECRET_ACCESS_KEY=YOUR_SECRET_ACCESS_KEY \
      --env BEDROCK_MODEL=arn:aws:bedrock:us-east-1:YOUR_ACCOUNT_ID:inference-profile/us.anthropic.claude-sonnet-4-6 \
      --env CAN_CHANGE_KEYS=false \
      --volume "./app_data:/app_data" \
      ghcr.io/presenton/presenton:latest
    ```
  </Tab>
</Tabs>

You can instead set the same values in Settings → Text provider or in the `.env` file used by Docker Compose.

## 5. Test the connection

Open [http://localhost:5001](http://localhost:5001), generate a two-slide presentation, and inspect the container logs if generation fails:

```bash theme={null}
docker logs --tail 150 presenton
```

## Troubleshooting

<AccordionGroup>
  <Accordion title="On-demand throughput is not supported">
    The model requires a foundation model or inference profile ARN. Copy the full inference profile ARN from the same region in the Bedrock console and use it as `BEDROCK_MODEL`.
  </Accordion>

  <Accordion title="AccessDeniedException">
    Confirm the principal has `bedrock:InvokeModel` and `bedrock:InvokeModelWithResponseStream` for the model or inference profile, and confirm model access is enabled for the AWS account.
  </Accordion>

  <Accordion title="Model not found or invalid identifier">
    Check the model string for whitespace, confirm it exists in `BEDROCK_REGION`, and use a full inference profile ARN for models that require one.
  </Accordion>

  <Accordion title="Bedrock authentication is incomplete">
    Supply `BEDROCK_API_KEY`, or supply both `BEDROCK_AWS_ACCESS_KEY_ID` and `BEDROCK_AWS_SECRET_ACCESS_KEY`. Do not mix the two authentication methods.
  </Accordion>

  <Accordion title="Temporary credentials fail">
    Include `BEDROCK_AWS_SESSION_TOKEN`, verify that the credentials have not expired, and restart Presenton after replacing them.
  </Accordion>
</AccordionGroup>

<Check>
  Presenton can generate and edit a test presentation through the selected Bedrock model in the configured region.
</Check>


# Use a local model with Ollama
Source: https://docs.presenton.ai/hosting/providers/ollama

Connect Docker-based Presenton to an Ollama model running on your machine.

This setup keeps text-generation requests on your machine. Image or search requests remain external unless you also choose local providers or disable those features.

## 1. Install and start Ollama

Install Ollama for your operating system, then pull a model:

```bash theme={null}
ollama pull llama3.2:3b
```

Confirm the service responds:

```bash theme={null}
ollama list
```

## 2. Start Presenton with the Ollama settings

```bash theme={null}
docker run --name presenton \
  --publish 5001:80 \
  --add-host host.docker.internal:host-gateway \
  --volume "./app_data:/app_data" \
  --env LLM=ollama \
  --env OLLAMA_URL=http://host.docker.internal:11434 \
  --env OLLAMA_MODEL=llama3.2:3b \
  --env DISABLE_IMAGE_GENERATION=true \
  --env MEM0_ENABLED=false \
  ghcr.io/presenton/presenton:latest
```

On Docker Desktop, `host.docker.internal` normally works without the extra host mapping. Keeping it in the command is useful for compatible Linux Docker setups.

## 3. Verify the connection

Open [http://localhost:5001](http://localhost:5001), go to text-provider settings, choose Ollama, and use the model check. Confirm `llama3.2:3b` appears as available.

## 4. Generate a small test deck

Create a three- or four-slide presentation with a straightforward prompt. Smaller local models may need simpler instructions and may be less reliable with complex structured layouts.

## 5. Add local capabilities gradually

* Enable Mem0 after configuring a compatible local memory model.
* Use ComfyUI for local image generation.
* Use SearXNG for self-hosted web search.
* Give Docker GPU access when the model runtime can use it.

<Warning>
  `localhost` inside the Presenton container points to the container itself. Use a host gateway or container-network hostname that Presenton can reach.
</Warning>


# System requirements
Source: https://docs.presenton.ai/hosting/system-requirements

Choose practical CPU, memory, storage, network, and optional GPU capacity for self-hosted Presenton.

Presenton runs the web application, API, document parser, OCR, and presentation export service in one container. Text and image generation can run on hosted providers or on separate local model services such as Ollama and ComfyUI.

<Note>
  The estimates below cover the Presenton application and assume that text and image models run on hosted providers. Add the [local model capacity](#local-model-and-gpu-capacity) when Ollama, LM Studio, ComfyUI, or another inference service runs on the same host.
</Note>

## Recommended server sizes

Use these tiers as initial capacity, not as hard limits. An **active job** means a presentation being generated, a document being parsed, or a presentation being exported—not simply a user with the page open.

| Deployment                 |        CPU |        Memory | Free SSD space | Practical starting workload                                                 |
| -------------------------- | ---------: | ------------: | -------------: | --------------------------------------------------------------------------- |
| Evaluation or personal use | **2 vCPU** |  **4 GB RAM** |      **10 GB** | One active job at a time, small or normal documents, hosted AI providers    |
| Small team (recommended)   | **4 vCPU** |  **8 GB RAM** |   **20–50 GB** | About 2 simultaneous active jobs, regular uploads and exports               |
| Document-heavy or API use  | **8 vCPU** | **16 GB RAM** | **50–100+ GB** | About 4 simultaneous active jobs, large PDFs, OCR, or sustained API traffic |

<Warning>
  Do not plan a production deployment with less than 2 vCPU or 4 GB RAM. The interface may start on a smaller host, but document parsing, Chromium-based export, and overlapping jobs can run out of memory or become unresponsive.
</Warning>

For production, prefer sustained CPU capacity over a heavily throttled or burst-only instance. Capacity is shared with the operating system, Docker, a reverse proxy, and any database or local provider on the host; do not count memory reserved for those services as available to Presenton.

## How to adjust the estimate

Start with the tier closest to the expected workload, then increase it when any of the following apply:

* Add approximately **1–2 vCPU and 2 GB RAM for each additional simultaneous document-processing or export job**. This is a planning allowance; measure the actual files and templates used by your team.
* Use at least **8 GB RAM** when users regularly upload long, scanned, image-heavy, or high-resolution PDFs.
* Increase CPU before raising `LITEPARSE_NUM_WORKERS`. As a starting rule, keep at least one CPU core available for the application and do not configure more parser workers than the remaining vCPUs.
* Leave memory headroom for short peaks. Avoid setting the container memory limit equal to its normal observed usage.
* Provider latency and rate limits can remain the bottleneck even after the server is enlarged.

## Host and container requirements

| Component         | Requirement                                                              |
| ----------------- | ------------------------------------------------------------------------ |
| Architecture      | 64-bit `amd64` (x86-64) or `arm64`                                       |
| Production host   | A currently supported 64-bit Linux distribution                          |
| Container runtime | A current Docker Engine release or compatible container platform         |
| Source deployment | Git and Docker Compose v2 in addition to Docker Engine                   |
| Application port  | A host port routed to container port `80`; examples use host port `5001` |
| Persistent data   | A durable volume mounted at `/app_data`                                  |
| Browser           | A current version of Chrome, Edge, Firefox, or Safari                    |

The published container includes the application runtime, Chromium, OCR, fonts, and export dependencies. A server running the published image does **not** need a separate Node.js, Python, Chromium, or Tesseract installation. Building from source is more demanding; allow at least **4 vCPU, 8 GB RAM, and 20 GB of free disk** during the build.

Docker Desktop on macOS or Windows is suitable for evaluation and local use. A Linux host is the recommended production target.

## Storage planning

Mount `/app_data` on persistent, low-latency SSD or block storage. It can contain the database, uploaded source files, generated images, presentations, templates, local memory, and exported PPTX or PDF files.

Reserve storage for all of the following:

* **5–10 GB for container images and upgrades.** An upgrade can temporarily keep both the old and new image on disk.
* **Uploads at their original size.** Retained source documents are not represented by the presentation count alone.
* **Approximately 50–250 MB per retained, image-rich 10-slide presentation** as an initial estimate for generated assets and exports. Image resolution, source files, templates, and multiple export copies can raise this substantially.
* **At least 20% free space** so exports, uploads, database writes, and upgrades have working room.
* **Backup capacity outside the application volume.** A full backup needs space comparable to the used size of `/app_data`; keep additional generations according to the retention policy.

For example, a team retaining 100 image-rich presentations should start with roughly **25–50 GB** for Presenton data and operating headroom, then adjust from measured growth. The 10 GB minimum is intended only for evaluation with limited retained content.

An external PostgreSQL or MySQL database does not replace `/app_data`; files and generated assets still require persistent storage. See [Storage and processing](/self-hosted/configuration/storage-and-processing) and [Backups and recovery](/hosting/backups-and-recovery).

## Network and ports

Presenton needs stable outbound access to every configured text, image, search, database, and authentication provider.

| Direction                   | Port or protocol                   | Purpose                                                                   |
| --------------------------- | ---------------------------------- | ------------------------------------------------------------------------- |
| Inbound                     | Host port mapped to container `80` | Web interface, REST API, and MCP                                          |
| Inbound, optional           | TCP `1455`                         | ChatGPT/Codex OAuth callback only                                         |
| Outbound                    | DNS and HTTPS (`443`)              | Container registry, hosted AI, image, search, and authentication services |
| Outbound or private network | Provider-specific                  | Ollama, LM Studio, ComfyUI, SearXNG, and external databases               |

There is no fixed bandwidth requirement. For planning, use a stable **10 Mbps connection as an evaluation floor** and **50 Mbps or more for a team** that frequently uploads documents or generates images. Latency to hosted providers usually affects generation time more than raw bandwidth.

Publish port `1455` only when the ChatGPT/Codex authentication callback is required. Put remote deployments behind HTTPS, enable authentication, and restrict provider and database ports to trusted networks. See [Security and access](/hosting/security-and-access).

## Local model and GPU capacity

A GPU is **not required** when Presenton uses hosted text and image providers. Attaching a GPU to the Presenton container does not accelerate a hosted provider.

When a local model server shares the host, its model weights, context cache, and inference runtime are additional to the Presenton requirements. The following are rough allowances for common 4-bit-quantized text models:

| Local text model size | Additional system RAM or GPU VRAM | Suggested total host memory |
| --------------------- | --------------------------------: | --------------------------: |
| 3B–4B parameters      |                            4–6 GB |                   16 GB RAM |
| 7B–8B parameters      |                           6–10 GB |                16–24 GB RAM |
| 13B–14B parameters    |                          10–16 GB |                   32 GB RAM |
| 30B–32B parameters    |                          24–32 GB |                48–64 GB RAM |

Long context windows, higher-precision weights, multiple loaded models, and concurrent inference require more memory. CPU-only inference works but can be much slower; plan **8 or more modern CPU cores** for a small local model when generation speed matters.

For local image generation through ComfyUI, **8 GB VRAM is a practical floor** for smaller or optimized workflows, while **12–16+ GB VRAM** is a better starting point for higher-resolution or more complex workflows. Exact requirements are determined by the selected checkpoint and workflow.

NVIDIA GPU passthrough requires a compatible NVIDIA driver, the NVIDIA Container Toolkit, and a container started with GPU access. A local provider running on another machine needs no GPU on the Presenton host.

## Validate before production

1. Deploy the recommended tier for the expected workload.
2. Generate a representative presentation from the largest typical source document.
3. Export it to every format the team uses.
4. Repeat with the expected number of simultaneous active jobs.
5. Record peak CPU, memory, temporary disk use, `/app_data` growth, provider latency, and job duration.
6. Keep at least **25% memory headroom** and **20% disk headroom** after the test; move up a tier if either margin is not available.

<CardGroup>
  <Card title="Deploy with Docker" icon="docker" href="/hosting/docker">
    Run the published image or build Presenton from source.
  </Card>

  <Card title="Performance and scaling" icon="gauge-high" href="/hosting/performance-and-scaling">
    Measure bottlenecks and tune the deployment after launch.
  </Card>
</CardGroup>


# Presenton Documentation
Source: https://docs.presenton.ai/index

Create, edit, automate, and operate Presenton across Cloud and self-hosted deployments.

<div>
  <section>
    <div>Build with <span>Presenton</span></div>
    <p>Editable presentation workflows for prompts, files, templates, and APIs.</p>
  </section>

  <section aria-label="Presenton documentation paths">
    <div>
      <a href="/general/overview" aria-label="Understand Presenton" />

      <div>
        <img alt="" />

        <img alt="" />
      </div>

      <div>
        <p>Understand Presenton</p>
        <p>Start with the product overview, workflow, core concepts, deployment modes, and feature availability.</p>
      </div>
    </div>

    <div>
      <a href="/user-guide/create-new-presentation" aria-label="Create and edit decks" />

      <div>
        <img alt="" />

        <img alt="" />
      </div>

      <div>
        <p>Create and edit decks</p>
        <p>Generate a first draft, refine slides, work with content blocks, and export to PPTX or PDF.</p>
      </div>
    </div>

    <div>
      <a href="/user-guide/branding-and-design/templates" aria-label="Use reusable templates" />

      <div>
        <img alt="" />

        <img alt="" />
      </div>

      <div>
        <p>Use reusable templates</p>
        <p>Bring existing presentation designs into repeatable templates for consistent, editable output.</p>
      </div>
    </div>

    <div>
      <a href="/hosting/overview" aria-label="Run Presenton yourself" />

      <div>
        <img alt="" />

        <img alt="" />
      </div>

      <div>
        <p>Run Presenton yourself</p>
        <p>Install Presenton with Docker, configure providers, and explore support for custom enterprise requirements.</p>
      </div>
    </div>

    <div>
      <a href="/user-guide/api-and-automation/overview" aria-label="Build with the API" />

      <div>
        <img alt="" />

        <img alt="" />
      </div>

      <div>
        <p>Build with the API</p>
        <p>Generate, track, edit, and export presentations from your product, automation, or internal workflow.</p>
      </div>
    </div>

    <div>
      <a href="/troubleshooting" aria-label="Troubleshoot and compare versions" />

      <div>
        <img alt="" />

        <img alt="" />
      </div>

      <div>
        <p>Troubleshoot and compare versions</p>
        <p>Diagnose generation, editing, export, hosting, and integration issues, or open a frozen documentation snapshot.</p>
      </div>
    </div>
  </section>
</div>


# Authentication
Source: https://docs.presenton.ai/self-hosted/configuration/authentication

Configure multi-user access, administrator recovery, and API keys for the browser, REST API, and MCP server.

Presenton supports multiple accounts with a private workspace for each user. The first account becomes the primary administrator and can create, reset, or remove other accounts from **Admin → Users**.

<Note>
  Local accounts control access to this installation. The optional **Login with Presenton** device flow connects an installation-wide cloud generation provider; it does not replace local sign-in.
</Note>

## Set up the primary administrator

On a new installation, open Presenton and follow the account setup screen. For an unattended deployment, preseed the primary administrator on first boot. Usernames must contain at least three characters and new passwords must contain at least eight characters.

```bash theme={null}
docker run -it --name presenton \
  --publish 5001:80 \
  --env AUTH_USERNAME=admin \
  --env AUTH_PASSWORD=replace-with-a-long-password \
  --volume "./app_data:/app_data" \
  ghcr.io/presenton/presenton:latest
```

Or place them in a protected `.env` file for Compose:

```dotenv theme={null}
AUTH_USERNAME=admin
AUTH_PASSWORD=replace-with-a-long-password
```

If an account already exists, the startup values are ignored unless you explicitly enable credential override.

## Manage users

The primary administrator can open **Admin → Users** to create users, reset their passwords, or remove their access. Each user receives a private workspace for presentations, templates, tasks, and uploaded assets.

Existing single-user installations migrate automatically. The existing account becomes the primary administrator while its owned data remains attached to the same account.

## Connect an optional Presenton account

The primary administrator can choose **Presenton** during provider onboarding or in Settings, copy the displayed device code, and approve it on the hosted Presenton page. The resulting provider connection is shared by the installation and can be replaced or disconnected only by the administrator.

| Identity                     | Purpose                                                            | Storage                                       |
| ---------------------------- | ------------------------------------------------------------------ | --------------------------------------------- |
| Local Presenton user         | Signs in to the self-hosted browser and owns a private workspace   | Local application database and session cookie |
| Presenton account connection | Authorizes optional cloud-backed generation and document workflows | One encrypted global provider record          |
| Presenton API key            | Authenticates REST API and MCP requests                            | Hashed local API-key record                   |

Connecting the provider does not grant browser access to the self-hosted instance. Disconnecting it revokes the delegated cloud credentials without deleting local users or presentations.

## How each interface authenticates

| Interface            | Authentication                      |
| -------------------- | ----------------------------------- |
| Browser UI           | User sign-in session                |
| `/api/v1/*`          | Admin-generated Presenton API key   |
| `/mcp`               | Admin-generated Presenton API key   |
| Electron desktop app | Authentication and MCP are disabled |

## Create an API key

The primary administrator opens **Admin → API keys**, selects **Generate key**, and copies the new `sk-presenton-...` value. The key is shown only when it is created.

Send the key as a bearer token for REST API or MCP requests:

```bash theme={null}
curl --request GET \
  --url http://localhost:5001/api/v1/ppt/presentation/all \
  --header "Authorization: Bearer $PRESENTON_API_KEY"
```

API keys cannot sign in to the browser UI. Revoking a key from the admin panel takes effect immediately.

## Rotate credentials

Set the new username and password together with `AUTH_OVERRIDE_FROM_ENV=true`, replace the container, and then remove the override setting. Rotation preserves the administrator's user ID and owned data.

```bash theme={null}
docker stop presenton
```

Remove the stopped container:

```bash theme={null}
docker rm presenton
```

Start it once with credential override enabled:

```bash theme={null}
docker run -it --name presenton \
  --publish 5001:80 \
  --env AUTH_USERNAME=admin \
  --env AUTH_PASSWORD=replace-with-a-new-long-password \
  --env AUTH_OVERRIDE_FROM_ENV=true \
  --volume "./app_data:/app_data" \
  ghcr.io/presenton/presenton:latest
```

<Warning>
  Credential override invalidates existing browser sessions and API keys. Remove `AUTH_OVERRIDE_FROM_ENV` after the one-time rotation so every restart does not repeat the operation.
</Warning>

## Recover access

For one boot, start the instance with `RESET_AUTH=true` and supply the primary administrator's new username and password. Then stop the instance, remove the recovery variables, and start it normally.

```bash theme={null}
docker stop presenton
```

Remove the stopped container:

```bash theme={null}
docker rm presenton
```

Start it once with recovery enabled:

```bash theme={null}
docker run -it --name presenton \
  --publish 5001:80 \
  --env RESET_AUTH=true \
  --env AUTH_USERNAME=admin \
  --env AUTH_PASSWORD=replace-with-a-new-long-password \
  --volume "./app_data:/app_data" \
  ghcr.io/presenton/presenton:latest
```

<Warning>
  Do not manually remove authentication fields from `/app_data/userConfig.json`. Use the recovery variables so the database account and its ownership links remain intact.
</Warning>

<Card title="Connect an MCP client" icon="plug" href="/hosting/mcp">
  Generate an API key and configure compatible local or remote MCP clients.
</Card>


# Use ComfyUI for presentation images
Source: https://docs.presenton.ai/self-hosted/configuration/comfyui

Connect Presenton Open Source to a reachable ComfyUI server and an API-format image workflow.

Presenton can send generated image prompts to your own ComfyUI workflow. This supports local or hosted models such as FLUX, Stable Diffusion, and SDXL while keeping the image pipeline under your control.

## Before you start

* Build and test a text-to-image workflow directly in ComfyUI.
* Ensure the Presenton container can reach the ComfyUI server.
* Decide whether to configure the provider in **Settings** or with environment variables.

## 1. Expose ComfyUI to Presenton

Start ComfyUI on an interface reachable from the Presenton container:

```bash theme={null}
python main.py --listen 0.0.0.0
```

The default port is `8188`. Restrict network access with a firewall or private container network; an exposed ComfyUI server can run resource-intensive workflows.

| ComfyUI location       | Example URL from Presenton         |
| ---------------------- | ---------------------------------- |
| Docker host            | `http://host.docker.internal:8188` |
| Compose service        | `http://comfyui:8188`              |
| Another LAN host       | `http://192.168.1.100:8188`        |
| Secured remote service | `https://comfyui.example.com`      |

<Warning>
  `localhost` inside the Presenton container points to Presenton, not to ComfyUI running on the host.
</Warning>

## 2. Mark the prompt node

Presenton must know where to inject each image prompt:

1. Find the positive text-prompt node in ComfyUI.
2. Right-click it and choose **Title**.
3. Rename it to exactly `Input Prompt`.

Presenton searches the exported workflow for `_meta.title` equal to `Input Prompt` (case-insensitive), then replaces its writable prompt text. A compatible node resembles:

```json theme={null}
{
  "6": {
    "inputs": {
      "text": "placeholder prompt",
      "clip": ["4", 1]
    },
    "class_type": "CLIPTextEncode",
    "_meta": {
      "title": "Input Prompt"
    }
  }
}
```

## 3. Export the API workflow

1. Open ComfyUI settings and enable **Dev mode Options**.
2. Open **File** from the ComfyUI menu.
3. Choose **Export (API)**.

Use the API export, not the normal workflow save. Presenton needs the API node graph.

## 4. Configure Presenton

In **Settings → Image provider**, select **ComfyUI**, enter the server URL, paste the complete exported workflow JSON, and save.

For a managed deployment, set the same values as environment variables:

```dotenv theme={null}
IMAGE_PROVIDER=comfyui
COMFYUI_URL=http://host.docker.internal:8188
COMFYUI_WORKFLOW={"6":{"inputs":{"text":"placeholder prompt"},"class_type":"CLIPTextEncode","_meta":{"title":"Input Prompt"}}}
```

`COMFYUI_WORKFLOW` contains the exported JSON itself, not a filesystem path. For Compose, quote or escape the JSON according to your environment-file tooling. The Settings UI is often easier for large workflows.

## 5. Test the integration

Generate a short presentation that requests images, then verify:

* ComfyUI receives a job at `/prompt`.
* The `Input Prompt` node contains the generated prompt.
* The workflow produces an image output rather than only previews or latent data.
* Presenton can read the ComfyUI history and download the output.
* Repeated images use different seeds where supported by the workflow.

## Troubleshooting

| Symptom                            | Check                                                               |
| ---------------------------------- | ------------------------------------------------------------------- |
| Cannot connect                     | Test `COMFYUI_URL` from inside the Presenton container              |
| `Input Prompt` not found           | Re-export after renaming the prompt node                            |
| Workflow rejected                  | Confirm you used **Export (API)** and the workflow runs manually    |
| Job completes but no image appears | Ensure the workflow has a save/output image node                    |
| Every result looks identical       | Confirm the sampler seed is writable and not fixed by a custom node |

<Card title="Images and web search" icon="images" href="/self-hosted/configuration/images-and-search">
  Compare ComfyUI with stock, hosted, and OpenAI-compatible image providers.
</Card>


# Images and web search
Source: https://docs.presenton.ai/self-hosted/configuration/images-and-search

Configure stock images, generated visuals, compatible image APIs, and optional web research.

Image generation and web research are separate from the text model. You can combine providers—for example, Ollama for text, Pexels for images, and a private SearXNG instance for search.

## Image providers

Set `IMAGE_PROVIDER` to one of the supported values.

| Capability                  | `IMAGE_PROVIDER`    | Required or related settings                       |
| --------------------------- | ------------------- | -------------------------------------------------- |
| Pexels stock images         | `pexels`            | `PEXELS_API_KEY`                                   |
| Pixabay stock images        | `pixabay`           | `PIXABAY_API_KEY`                                  |
| Gemini Flash images         | `gemini_flash`      | `GOOGLE_API_KEY`                                   |
| Nano Banana Pro             | `nanobanana_pro`    | `GOOGLE_API_KEY`                                   |
| DALL·E 3                    | `dall-e-3`          | `OPENAI_API_KEY`, optional quality                 |
| GPT Image 1.5               | `gpt-image-1.5`     | `OPENAI_API_KEY`, optional quality                 |
| ComfyUI                     | `comfyui`           | `COMFYUI_URL`, optional workflow                   |
| Open WebUI                  | `open_webui`        | `OPEN_WEBUI_IMAGE_URL`, `OPEN_WEBUI_IMAGE_API_KEY` |
| OpenAI-compatible image API | `openai_compatible` | Base URL, API key, and model                       |

Set `DISABLE_IMAGE_GENERATION=true` to create presentations without generated or searched images.

### Stock-image example

```dotenv theme={null}
IMAGE_PROVIDER=pexels
PEXELS_API_KEY=replace-with-your-key
```

### OpenAI image example

```dotenv theme={null}
IMAGE_PROVIDER=gpt-image-1.5
OPENAI_API_KEY=replace-with-your-key
GPT_IMAGE_1_5_QUALITY=medium
```

Supported GPT Image 1.5 quality values are `low`, `medium`, and `high`; the default is `medium`. DALL·E 3 supports `standard` and `hd` quality.

### ComfyUI example

```dotenv theme={null}
IMAGE_PROVIDER=comfyui
COMFYUI_URL=http://host.docker.internal:8188
COMFYUI_WORKFLOW={"6":{"inputs":{"text":"placeholder prompt"},"class_type":"CLIPTextEncode","_meta":{"title":"Input Prompt"}}}
```

`COMFYUI_WORKFLOW` contains the API-exported workflow JSON. The prompt node must be titled `Input Prompt` so Presenton can inject each generated prompt.

<Card title="Configure ComfyUI step by step" icon="image" href="/self-hosted/configuration/comfyui">
  Expose the server safely, prepare the prompt node, export the API workflow, and troubleshoot generation.
</Card>

### OpenAI-compatible image API

```dotenv theme={null}
IMAGE_PROVIDER=openai_compatible
OPENAI_COMPAT_IMAGE_BASE_URL=https://proxy.example.com/v1
OPENAI_COMPAT_IMAGE_API_KEY=replace-with-your-key
OPENAI_COMPAT_IMAGE_MODEL=gpt-image-1
```

This is useful for gateways such as LiteLLM or another service that exposes a compatible image endpoint. It does not change the text provider.

## Web search

Web search is opt-in. Enable it only when decks need current public information.

```dotenv theme={null}
WEB_GROUNDING=true
WEB_SEARCH_PROVIDER=auto
WEB_SEARCH_MAX_RESULTS=5
```

| `WEB_SEARCH_PROVIDER` | Behavior                                                                                            | Additional setting         |
| --------------------- | --------------------------------------------------------------------------------------------------- | -------------------------- |
| `auto`                | Uses native search for supported OpenAI, Google, or Anthropic configurations; otherwise remains off | None                       |
| `native`              | Requests native provider search                                                                     | A compatible text provider |
| `searxng`             | Uses a self-hosted SearXNG instance                                                                 | `SEARXNG_BASE_URL`         |
| `tavily`              | Uses Tavily                                                                                         | `TAVILY_API_KEY`           |
| `exa`                 | Uses Exa                                                                                            | `EXA_API_KEY`              |

`WEB_SEARCH_MAX_RESULTS` defaults to `5` and supports up to `10` results.

<Tabs>
  <Tab title="SearXNG">
    ```dotenv theme={null}
    WEB_GROUNDING=true
    WEB_SEARCH_PROVIDER=searxng
    SEARXNG_BASE_URL=http://searxng:8080
    WEB_SEARCH_MAX_RESULTS=5
    ```
  </Tab>

  <Tab title="Tavily">
    ```dotenv theme={null}
    WEB_GROUNDING=true
    WEB_SEARCH_PROVIDER=tavily
    TAVILY_API_KEY=replace-with-your-key
    WEB_SEARCH_MAX_RESULTS=5
    ```
  </Tab>

  <Tab title="Exa">
    ```dotenv theme={null}
    WEB_GROUNDING=true
    WEB_SEARCH_PROVIDER=exa
    EXA_API_KEY=replace-with-your-key
    WEB_SEARCH_MAX_RESULTS=5
    ```
  </Tab>
</Tabs>

<Warning>
  Web results and generated images can introduce inaccurate, outdated, or licensed material. Review facts, citations, image rights, and attribution requirements before sharing a presentation.
</Warning>


# Configure by goal
Source: https://docs.presenton.ai/self-hosted/configuration/recipes

Choose a feature, then set the exact ports and environment variables it requires.

Use this page when you know what you want Presenton to do but do not yet know which settings make it happen.

## Quick decision table

| Goal                               | Required ports                                         | Main settings or actions                                           |
| ---------------------------------- | ------------------------------------------------------ | ------------------------------------------------------------------ |
| Open the browser application       | `5001:80` by default                                   | Mount `/app_data`; select a text provider                          |
| Use a ChatGPT/Codex subscription   | `5001:80` and `1455:1455`                              | `LLM=codex`, `CODEX_MODEL`; complete **Sign in with ChatGPT**      |
| Use an API-key provider            | `5001:80`                                              | `LLM`, provider API key, and provider model                        |
| Use the REST API                   | `5001:80`                                              | Admin-generated Presenton API key                                  |
| Use MCP                            | `5001:80`                                              | Admin-generated Presenton API key, client URL ending in `/mcp`     |
| Use Ollama on the Docker host      | `5001:80`; Ollama must be reachable from the container | `LLM=ollama`, `OLLAMA_URL`, `OLLAMA_MODEL`                         |
| Enable stock or generated images   | `5001:80`                                              | `IMAGE_PROVIDER` plus its credentials or endpoint                  |
| Generate without images            | `5001:80`                                              | `DISABLE_IMAGE_GENERATION=true`                                    |
| Enable web research                | `5001:80`                                              | `WEB_GROUNDING=true`, `WEB_SEARCH_PROVIDER`, optional provider key |
| Lock provider settings             | `5001:80`                                              | `CAN_CHANGE_KEYS=false`                                            |
| Persist presentations and settings | No extra port                                          | Mount durable storage at `/app_data`                               |
| Use an external database           | Database must be reachable from the container          | `DATABASE_URL`, `MIGRATE_DATABASE_ON_STARTUP`                      |
| Disable anonymous telemetry        | No extra port                                          | `DISABLE_ANONYMOUS_TRACKING=true`                                  |

## Use an existing ChatGPT or Codex subscription

Choose the Codex provider when you want to sign in with a free or paid ChatGPT account instead of supplying an OpenAI API key.

The OAuth redirect is fixed to:

```text theme={null}
http://localhost:1455/auth/callback
```

Therefore Docker must publish both ports:

* `5001:80` for the Presenton browser application.
* `1455:1455` for the ChatGPT/Codex OAuth callback.

```bash theme={null}
docker run -it --name presenton \
  --publish 5001:80 \
  --publish 1455:1455 \
  --env LLM=codex \
  --env CODEX_MODEL=gpt-5.5 \
  --volume "./app_data:/app_data" \
  ghcr.io/presenton/presenton:latest
```

Then open Presenton, go to the text-provider settings, select **Sign in with ChatGPT**, complete authentication in the browser, and choose a supported Codex model.

<Warning>
  If `1455:1455` is missing, the OpenAI sign-in page may open, but the redirect cannot reach the callback server inside the container. This port is not needed for normal API-key providers.
</Warning>

The current `v0.9.7-beta` application accepts `gpt-5.6`, `gpt-5.5`, `gpt-5.4`, `gpt-5.4-mini`, and `gpt-5.3-codex-spark` as Codex model identifiers. Availability can still depend on the signed-in account.

### Docker Compose

The repository's `production`, `production-gpu`, `development`, and `development-gpu` services already map `1455:1455`.

```dotenv theme={null}
LLM=codex
CODEX_MODEL=gpt-5.5
```

```bash theme={null}
docker compose up production
```

### Remote Docker host

Because the browser redirect targets `localhost:1455`, `localhost` means the machine running the browser. When Presenton runs on another host, use an approved network arrangement that makes both Presenton and the callback available locally. For an SSH-accessible server, one option is local port forwarding:

```bash theme={null}
ssh -L 5001:localhost:5001 -L 1455:localhost:1455 user@presenton-server
```

While the tunnel is active, open `http://localhost:5001` and complete the ChatGPT sign-in from that browser session.

<Note>
  Port `1455` is for Codex OAuth, not MCP. MCP uses the normal Presenton web port and `/mcp` path.
</Note>

## Use OpenAI with an API key

This path uses API billing and does not require port `1455`.

```bash theme={null}
docker run -it --name presenton \
  --publish 5001:80 \
  --env LLM=openai \
  --env OPENAI_API_KEY=YOUR_OPENAI_API_KEY \
  --env OPENAI_MODEL=gpt-4.1 \
  --env IMAGE_PROVIDER=dall-e-3 \
  --env DALL_E_3_QUALITY=standard \
  --env CAN_CHANGE_KEYS=false \
  --volume "./app_data:/app_data" \
  ghcr.io/presenton/presenton:latest
```

`CAN_CHANGE_KEYS=false` hides and locks provider credentials in the UI. Leave it `true` or unset for a personal instance where settings should remain editable.

## Use Google for text and images

One Google API key can supply the Gemini text and image modes:

```dotenv theme={null}
LLM=google
GOOGLE_API_KEY=replace-with-your-key
GOOGLE_MODEL=models/gemini-2.0-flash
IMAGE_PROVIDER=gemini_flash
CAN_CHANGE_KEYS=false
```

Use `LLM=vertex` and the Vertex-specific authentication settings when you need Google Cloud project controls instead of the direct Gemini API.

## Run text generation locally with Ollama

Run Ollama on the Docker host, pull the model there, and point Presenton at the host gateway:

```bash theme={null}
ollama pull llama3.2:3b
```

```dotenv theme={null}
LLM=ollama
OLLAMA_URL=http://host.docker.internal:11434
OLLAMA_MODEL=llama3.2:3b
START_OLLAMA=false
```

`START_OLLAMA=false` means Presenton does not start its own Ollama service. If `host.docker.internal` is unavailable on your Linux Docker setup, provide an equivalent reachable host gateway or run both services on the same Docker network.

To avoid sending image prompts to an external provider:

```dotenv theme={null}
DISABLE_IMAGE_GENERATION=true
```

For a more complete local visual workflow, configure ComfyUI instead of disabling images.

## Use local text with stock images

Text and images do not need to use the same provider:

```dotenv theme={null}
LLM=ollama
OLLAMA_URL=http://host.docker.internal:11434
OLLAMA_MODEL=llama3.2:3b

IMAGE_PROVIDER=pexels
PEXELS_API_KEY=replace-with-your-key
```

This keeps text generation local while sending image searches to Pexels.

## Enable current-information web research

For supported OpenAI, Google, and Anthropic configurations, `auto` uses the provider's native search behavior:

```dotenv theme={null}
WEB_GROUNDING=true
WEB_SEARCH_PROVIDER=auto
WEB_SEARCH_MAX_RESULTS=5
```

For other text providers, choose an external search provider explicitly:

```dotenv theme={null}
WEB_GROUNDING=true
WEB_SEARCH_PROVIDER=searxng
SEARXNG_BASE_URL=http://searxng:8080
WEB_SEARCH_MAX_RESULTS=5
```

Set `WEB_GROUNDING=false` when current public information is unnecessary or external research is not allowed.

## Enable the REST API and MCP

Both interfaces use the normal web port. Configure the primary administrator first:

```dotenv theme={null}
AUTH_USERNAME=admin
AUTH_PASSWORD=replace-with-a-long-password
```

Open **Admin → API keys**, generate a `sk-presenton-...` key, and send it as a bearer token:

* REST API: `http://localhost:5001/api/v1`
* MCP: `http://localhost:5001/mcp`

No additional MCP port is required. The Electron desktop app does not expose MCP.

<CardGroup>
  <Card title="Generate with the API" icon="brackets-curly" href="/user-guide/api-and-automation/open-source-api-tutorial">
    Upload documents and generate PPTX or PDF output over REST.
  </Card>

  <Card title="Connect MCP" icon="plug" href="/hosting/mcp">
    Generate an API key and configure local or remote clients.
  </Card>
</CardGroup>

## Improve document extraction

LiteParse defaults are suitable for most documents:

```dotenv theme={null}
LITEPARSE_DPI=120
LITEPARSE_NUM_WORKERS=1
```

Increase `LITEPARSE_DPI` when scanned or image-heavy documents need clearer OCR. Increase workers only when the host has enough CPU and memory for concurrent parsing.

## Use an external database

Without `DATABASE_URL`, Presenton uses SQLite under `/app_data`. For an external database:

```dotenv theme={null}
DATABASE_URL=postgresql://presenton:password@postgres:5432/presenton
MIGRATE_DATABASE_ON_STARTUP=true
```

The database hostname must be reachable from the container. Continue mounting `/app_data`; presentations, uploads, templates, exports, authentication state, and memory are not all replaced by the external database.

## Apply configuration changes

Environment changes require a container restart or recreation:

```bash theme={null}
docker compose up --detach --force-recreate production
```

Check the restarted service separately:

```bash theme={null}
docker compose logs --tail 100 production
```

After every provider or networking change, generate a short test presentation and verify the browser, API, export, and MCP paths that your deployment intends to support.


# Storage and processing
Source: https://docs.presenton.ai/self-hosted/configuration/storage-and-processing

Configure app data, databases, presentation memory, document parsing, and telemetry.

Presenton stores more than database records. Plan persistence for `/app_data` first, then add an external database or tune document and memory processing when the workload requires it.

## Persistent app data

`/app_data` contains presentations, uploaded files, generated assets, templates, exports, settings, authentication state, the default SQLite database, and local memory data.

```bash theme={null}
docker run -it --name presenton \
  --publish 5001:80 \
  --volume "./app_data:/app_data" \
  ghcr.io/presenton/presenton:latest
```

Use a named volume or durable platform disk in production. Back it up before image upgrades, migrations, or authentication recovery.

## Database

Without `DATABASE_URL`, Presenton uses SQLite in `/app_data`. This is suitable for personal and small single-instance deployments.

Set `DATABASE_URL` to move application records to PostgreSQL or MySQL. Keep `/app_data` persistent as well—generated assets, uploads, exports, templates, and local memory are still stored there.

<Tabs>
  <Tab title="PostgreSQL">
    ```dotenv theme={null}
    DATABASE_URL=postgresql://presenton:password@postgres:5432/presenton
    MIGRATE_DATABASE_ON_STARTUP=true
    ```
  </Tab>

  <Tab title="MySQL">
    ```dotenv theme={null}
    DATABASE_URL=mysql://presenton:password@mysql:3306/presenton
    MIGRATE_DATABASE_ON_STARTUP=true
    ```
  </Tab>
</Tabs>

The repository's Compose services enable startup migrations. For production, take a database backup before applying a new release and avoid running multiple instances through a migration until you have verified the release's deployment behavior.

## Presentation memory

Presenton uses Mem0 OSS with local Qdrant and SQLite storage. Memory is scoped to a presentation and helps the assistant preserve relevant context during iterative edits.

| Variable                   | Default                                             | Purpose                                       |
| -------------------------- | --------------------------------------------------- | --------------------------------------------- |
| `MEM0_ENABLED`             | `true`                                              | Enable or disable memory                      |
| `MEM0_LLM_MODEL`           | `OLLAMA_MODEL` or `llama3.1:latest`                 | Model used by memory extraction               |
| `MEM0_LLM_API_KEY`         | `ollama`                                            | API-key placeholder for the compatible client |
| `MEM0_LLM_BASE_URL`        | `OLLAMA_URL` or `http://host.docker.internal:11434` | Memory model endpoint                         |
| `MEM0_DIR`                 | `/app_data/mem0`                                    | Local memory storage root                     |
| `MEM0_EMBEDDER_PROVIDER`   | `fastembed`                                         | Embedding provider                            |
| `MEM0_EMBEDDER_MODEL`      | `BAAI/bge-small-en-v1.5`                            | Embedding model                               |
| `MEM0_EMBEDDING_DIMS`      | `384`                                               | Vector dimensions                             |
| `MEM0_SPACY_MODEL`         | `en_core_web_sm`                                    | spaCy model                                   |
| `MEM0_REQUIRE_SPACY_MODEL` | `true`                                              | Require the configured spaCy model            |

The official Docker image includes the required spaCy model. Disable Mem0 if your deployment does not need iterative presentation memory or cannot reach the configured memory model.

## Document parsing

LiteParse extracts content from uploaded documents before the presentation outline is generated.

```dotenv theme={null}
LITEPARSE_DPI=120
LITEPARSE_NUM_WORKERS=1
```

Increase DPI when image-heavy or scanned documents need clearer extraction, at the cost of memory and processing time. Increase workers only after measuring available CPU and memory under concurrent uploads.

<Card title="Supported document formats" icon="file-lines" href="/self-hosted/features/document-extraction">
  Review supported office documents, PDFs, spreadsheets, text files, and images.
</Card>

## Telemetry

Disable anonymous tracking with:

```dotenv theme={null}
DISABLE_ANONYMOUS_TRACKING=true
```

This setting controls anonymous product telemetry; it does not prevent a configured hosted AI, image, or search provider from receiving the content sent to that provider. Use local providers and disable external search and images when the workflow requires local-only processing.

## Backup checklist

* Back up `/app_data` on a regular schedule.
* Back up the external database separately when `DATABASE_URL` is set.
* Test restoration in a separate instance.
* Protect backups because they may contain uploaded documents and generated presentations.
* Keep the application version and configuration used by each backup.


# Text providers
Source: https://docs.presenton.ai/self-hosted/configuration/text-providers

Configure hosted models, local runtimes, model gateways, and OpenAI-compatible endpoints.

The text provider creates outlines, writes slide content, and powers AI-assisted edits. Select one provider in the application, or set `LLM` and that provider's required credentials and model where environment-based configuration is supported.

## Supported providers

| Provider              | `LLM` value  | Required settings                                             | Common optional settings                                               |
| --------------------- | ------------ | ------------------------------------------------------------- | ---------------------------------------------------------------------- |
| Presenton Cloud       | `presenton`  | Administrator-approved device login in onboarding or Settings | None                                                                   |
| OpenAI                | `openai`     | `OPENAI_API_KEY`                                              | `OPENAI_MODEL` (default `gpt-4.1`)                                     |
| DeepSeek              | `deepseek`   | `DEEPSEEK_API_KEY`                                            | `DEEPSEEK_MODEL`, `DEEPSEEK_BASE_URL`                                  |
| Google Gemini         | `google`     | `GOOGLE_API_KEY`                                              | `GOOGLE_MODEL`                                                         |
| Google Vertex AI      | `vertex`     | `VERTEX_API_KEY`, or project credentials                      | `VERTEX_MODEL`, `VERTEX_PROJECT`, `VERTEX_LOCATION`, `VERTEX_BASE_URL` |
| Azure OpenAI          | `azure`      | API key, model, API version, and endpoint or base URL         | Deployment name                                                        |
| Amazon Bedrock        | `bedrock`    | Region, model, and one supported AWS credential method        | Session token or profile                                               |
| OpenRouter            | `openrouter` | `OPENROUTER_API_KEY`, `OPENROUTER_MODEL`                      | `OPENROUTER_BASE_URL`                                                  |
| Fireworks             | `fireworks`  | `FIREWORKS_API_KEY`, `FIREWORKS_MODEL`                        | `FIREWORKS_BASE_URL`                                                   |
| Together AI           | `together`   | `TOGETHER_API_KEY`, `TOGETHER_MODEL`                          | `TOGETHER_BASE_URL`                                                    |
| Cerebras              | `cerebras`   | `CEREBRAS_API_KEY`                                            | `CEREBRAS_MODEL`, `CEREBRAS_BASE_URL`                                  |
| Anthropic             | `anthropic`  | `ANTHROPIC_API_KEY`                                           | `ANTHROPIC_MODEL`                                                      |
| LiteLLM               | `litellm`    | `LITELLM_BASE_URL`, `LITELLM_MODEL`                           | `LITELLM_API_KEY`                                                      |
| LM Studio             | `lmstudio`   | `LMSTUDIO_BASE_URL`, `LMSTUDIO_MODEL`                         | `LMSTUDIO_API_KEY`                                                     |
| Ollama                | `ollama`     | `OLLAMA_MODEL`                                                | `OLLAMA_URL`, `START_OLLAMA`                                           |
| Custom compatible API | `custom`     | `CUSTOM_LLM_URL`, `CUSTOM_MODEL`                              | `CUSTOM_LLM_API_KEY`                                                   |
| ChatGPT through Codex | `codex`      | Interactive OAuth                                             | `CODEX_MODEL`                                                          |

Set `CAN_CHANGE_KEYS=false` to prevent provider keys from being changed in the UI.

## Presenton Cloud provider

Use this provider when you want the self-hosted interface and local dashboard with generation handled by a connected Presenton account. Sign in to the local administrator account, choose **Presenton** during onboarding or in provider settings, and approve the displayed device code on the hosted Presenton page.

The approved connection is global to the installation and its delegated credentials are encrypted at rest. No API key, OAuth client secret, callback port, or provider environment variables are required. Selecting Presenton stores `LLM=presenton`; setting that value alone does not create the required account connection.

<Warning>
  This provider sends generation inputs and uploaded documents used in its workflows to Presenton Cloud. It does not authenticate users to the self-hosted browser, REST API, or MCP server.
</Warning>

## ChatGPT sign-in through Codex

Use this provider when you want to authenticate with an existing free or paid ChatGPT account instead of an OpenAI API key.

```dotenv theme={null}
LLM=codex
CODEX_MODEL=gpt-5.5
```

Docker must publish the OAuth callback port in addition to the application port:

```bash theme={null}
--publish 5001:80 --publish 1455:1455
```

Open Presenton, select **Sign in with ChatGPT**, and complete the browser flow. OpenAI redirects the browser to `http://localhost:1455/auth/callback`, so omitting the callback mapping prevents containerized sign-in from completing. The source repository's Compose services already publish this port.

<Note>
  Port `1455` is only for ChatGPT/Codex OAuth. The REST API and MCP server both use the normal Presenton web port.
</Note>

<Card title="Complete ChatGPT/Codex recipe" icon="right-to-bracket" href="/self-hosted/configuration/recipes#use-an-existing-chatgpt-or-codex-subscription">
  See Docker Run, Compose, supported model identifiers, and remote-host port forwarding.
</Card>

## Hosted-provider examples

<Tabs>
  <Tab title="OpenAI">
    ```dotenv theme={null}
    LLM=openai
    OPENAI_API_KEY=replace-with-your-key
    OPENAI_MODEL=gpt-4.1
    ```
  </Tab>

  <Tab title="Google Gemini">
    ```dotenv theme={null}
    LLM=google
    GOOGLE_API_KEY=replace-with-your-key
    GOOGLE_MODEL=models/gemini-2.0-flash
    ```
  </Tab>

  <Tab title="Anthropic">
    ```dotenv theme={null}
    LLM=anthropic
    ANTHROPIC_API_KEY=replace-with-your-key
    ANTHROPIC_MODEL=claude-3-5-sonnet-20241022
    ```
  </Tab>

  <Tab title="OpenRouter">
    ```dotenv theme={null}
    LLM=openrouter
    OPENROUTER_API_KEY=replace-with-your-key
    OPENROUTER_MODEL=openai/gpt-4o
    OPENROUTER_BASE_URL=https://openrouter.ai/api/v1
    ```
  </Tab>
</Tabs>

## Cloud-provider authentication

### Vertex AI

Use either an API key or Google Cloud project authentication—not both.

<Tabs>
  <Tab title="API key">
    ```dotenv theme={null}
    LLM=vertex
    VERTEX_API_KEY=replace-with-your-key
    VERTEX_MODEL=gemini-2.5-flash
    ```
  </Tab>

  <Tab title="Google Cloud project">
    ```dotenv theme={null}
    LLM=vertex
    VERTEX_PROJECT=your-project-id
    VERTEX_LOCATION=us-central1
    VERTEX_MODEL=gemini-2.5-flash
    ```
  </Tab>
</Tabs>

### Azure OpenAI

```dotenv theme={null}
LLM=azure
AZURE_OPENAI_API_KEY=replace-with-your-key
AZURE_OPENAI_MODEL=gpt-4.1
AZURE_OPENAI_API_VERSION=2024-10-21
AZURE_OPENAI_ENDPOINT=https://YOUR-RESOURCE.openai.azure.com
```

Provide at least one supported endpoint or base URL. If your Azure configuration uses a deployment name distinct from the model, set the corresponding deployment variable as well.

<Card title="Configure Amazon Bedrock" icon="cloud" href="/hosting/providers/amazon-bedrock">
  Choose an authentication method, model ID or inference profile, and the required IAM permissions.
</Card>

## Local and compatible providers

### Ollama

```dotenv theme={null}
LLM=ollama
OLLAMA_URL=http://host.docker.internal:11434
OLLAMA_MODEL=llama3.2:3b
START_OLLAMA=false
```

### LM Studio

```dotenv theme={null}
LLM=lmstudio
LMSTUDIO_BASE_URL=http://host.docker.internal:1234
LMSTUDIO_MODEL=openai/gpt-oss-20b
```

Presenton appends `/v1` to the LM Studio base URL when needed.

### Custom OpenAI-compatible API

```dotenv theme={null}
LLM=custom
CUSTOM_LLM_URL=https://gateway.example.com/v1
CUSTOM_LLM_API_KEY=replace-with-your-key
CUSTOM_MODEL=your-model-id
```

Use `DISABLE_THINKING=true` when a compatible model's reasoning mode causes unwanted behavior. Use `EXTENDED_REASONING` only with a provider and model that supports it.

## Apply and test changes

Restart the container after changing environment variables:

```bash theme={null}
docker compose up --detach --force-recreate production
```

Check the restarted service separately:

```bash theme={null}
docker compose logs --tail 100 production
```

Generate a short test presentation before relying on a new model in production. Provider access, supported model names, regional availability, and account quotas can all affect generation.

<Warning>
  A model being available from a provider does not guarantee that your account can invoke it. Confirm access and quotas in the provider console when authentication succeeds but generation fails.
</Warning>


# Contributing
Source: https://docs.presenton.ai/self-hosted/contributing

Report an issue or prepare a focused contribution to Presenton.

Presenton is open source under the Apache 2.0 license. Before writing code, check the repository's current contribution scope: contributions outside `electron/` may not be accepted at this time.

<CardGroup>
  <Card title="Report a bug" icon="bug" href="https://github.com/presenton/presenton/issues">
    Include reproduction steps, expected and actual behavior, and useful logs or screenshots.
  </Card>

  <Card title="Discuss a feature" icon="comments" href="https://github.com/presenton/presenton/discussions">
    Explain the user problem and the result you want before proposing implementation details.
  </Card>
</CardGroup>

## Current code contribution scope

The accepted scope centers on the Electron application, including its desktop application, FastAPI backend, Next.js frontend, and local runtime integrations.

```text theme={null}
presenton/
└── electron/        # Current contribution scope
    ├── desktop app
    ├── backend
    ├── frontend
    └── local runtime integrations
```

<Warning>
  Confirm the current scope in the canonical [CONTRIBUTING.md](https://github.com/presenton/presenton/blob/main/CONTRIBUTING.md) before starting. Repository policy can change independently of this documentation snapshot.
</Warning>

## Prepare the development environment

You need Node.js LTS, npm, Python, and the `uv` Python package manager.

```bash theme={null}
cd electron
```

Install the development dependencies:

```bash theme={null}
npm run setup:env
```

Then start the development environment:

```bash theme={null}
npm run dev
```

The setup command installs the Electron, FastAPI, and Next.js dependencies. `npm run dev` compiles TypeScript and starts the local backend and UI with the desktop application.

## Before opening a pull request

* Keep the change inside `electron/`, small, and focused.
* Verify both the development workflow and the relevant build workflow.
* Explain the problem, the change, and how you tested it.
* Include before-and-after screenshots for UI changes.
* Sign the Contributor License Agreement when prompted.
* Follow the repository Code of Conduct.

<Note>
  Pull requests left without a signed CLA for more than 30 days may be closed under the repository's contribution policy.
</Note>

## AI-assisted contributions

AI-assisted pull requests are welcome. State that AI tools were used, describe the testing performed, and confirm that you reviewed the generated code yourself.

<Card title="Read the canonical contribution guide" icon="github" href="https://github.com/presenton/presenton/blob/main/CONTRIBUTING.md">
  Check the live scope, setup steps, CLA policy, and community links before contributing.
</Card>


# Choose your AI providers
Source: https://docs.presenton.ai/self-hosted/core-concepts/providers

Select the services that write content, create images, and search the web.

A provider is simply the service Presenton calls for one job. You can mix local and hosted providers based on privacy, quality, speed, and cost.

## Choose three capabilities

<CardGroup>
  <Card title="Text" icon="message-lines">
    Creates outlines, writes slide content, and powers the AI assistant.
  </Card>

  <Card title="Images" icon="image">
    Finds stock photos or generates new visuals for slides.
  </Card>

  <Card title="Web search" icon="globe">
    Adds current public information when you enable research.
  </Card>
</CardGroup>

## Supported text providers

Presenton Cloud, OpenAI, Google Gemini, Anthropic, DeepSeek, Azure OpenAI, Vertex AI, Amazon Bedrock, OpenRouter, Fireworks, Together AI, Cerebras, LiteLLM, Ollama, LM Studio, custom OpenAI-compatible endpoints, and ChatGPT sign-in through Codex where supported.

## Use Presenton Cloud as a provider

In `v0.9.7-beta` and later, the local administrator can connect a Presenton account from onboarding or provider settings. Presenton displays a short device code and opens the hosted approval page. After approval, select **Presenton** as the text provider to route supported generation and document-upload workflows through Presenton Cloud.

<Note>
  This connection is a generation provider, not a sign-in method for the self-hosted application. Create or sign in to the local administrator account first.
</Note>

The connection applies to the entire installation:

* Only the local administrator can connect, replace, or disconnect it.
* Delegated access and refresh credentials are encrypted at rest and are not returned to the browser.
* Selecting the provider stores `LLM=presenton`; connecting it alone does not replace another selected provider.
* Disconnecting revokes the cloud credentials and deselects Presenton.
* Official builds include the public device-flow client configuration, so no OAuth client secret or registration is required.

<Warning>
  Presentations and documents processed through this provider leave the self-hosted environment. Use a local provider when your data-handling policy requires processing to remain on your infrastructure.
</Warning>

## Supported image providers

Pexels, Pixabay, Gemini Flash, Nano Banana Pro, DALL·E 3, GPT Image 1.5, ComfyUI, Open WebUI, and OpenAI-compatible image endpoints.

## Supported web search

Native provider search, self-hosted SearXNG, Tavily, and Exa.

| Your priority  | Good starting point                                                        |
| -------------- | -------------------------------------------------------------------------- |
| Easiest setup  | Connect Presenton Cloud, or use a hosted text model with Pexels or Pixabay |
| Local privacy  | Ollama or LM Studio with ComfyUI or no generated images                    |
| One gateway    | LiteLLM or OpenRouter                                                      |
| Private search | SearXNG                                                                    |

<Card title="Set up a local model" icon="laptop-code" href="/hosting/providers/ollama">
  Connect Presenton to Ollama step by step.
</Card>

<CardGroup>
  <Card title="Configure text providers" icon="microchip" href="/self-hosted/configuration/text-providers">
    Find exact environment variables and examples for every supported text provider.
  </Card>

  <Card title="Configure images and search" icon="images" href="/self-hosted/configuration/images-and-search">
    Set stock, generated-image, compatible API, and web research providers.
  </Card>
</CardGroup>


# v0.9.7-beta release notes
Source: https://docs.presenton.ai/self-hosted/release-notes

Presenton account connection, cloud-backed generation, migration, and reliability changes in Presenton v0.9.7-beta.

Presenton `v0.9.7-beta` lets a self-hosted installation connect a Presenton account as an optional generation provider. It also improves cloud-backed Smart and Standard workflows, provider lifecycle handling, exports, and dashboard behavior. These notes follow the [Docker v0.9.7-beta release](https://github.com/presenton/presenton/releases/tag/v0.9.7-beta), published August 17, 2026, and the [electron-v0.9.7-beta release](https://github.com/presenton/presenton/releases/tag/electron-v0.9.7-beta), published August 18, 2026.

## At a glance

<CardGroup>
  <Card title="Connect Presenton" icon="cloud-arrow-up">
    An administrator can approve a device code and use Presenton Cloud as an installation-wide generation provider.
  </Card>

  <Card title="Cloud-backed workflows" icon="arrows-rotate">
    Standard and Smart generation, document uploads, templates, assets, and streamed results work through the connected account.
  </Card>

  <Card title="More reliable experience" icon="shield-check">
    Provider revalidation, generation-mode persistence, exports, dialogs, and dashboard actions receive targeted fixes.
  </Card>
</CardGroup>

## What's changed

### Presenton account connection

* [Added **Login with Presenton**](https://github.com/presenton/presenton/pull/833) using an OAuth device flow that keeps the approval code out of callback URLs and browser history.
* Added administrator-managed connect, status, revalidation, and disconnect flows in onboarding and Settings.
* Stored delegated credentials as one encrypted, installation-wide provider record instead of per-user browser state.
* Kept the self-hosted administrator session separate from the optional Presenton account connection.

### Generation and templates

* Added `presenton` as a text-provider selection for linked installations.
* Routed linked Standard and Smart generation, document uploads, templates, and assistant requests through the Presenton Cloud workflow.
* Mirrored completed cloud presentations into the local dashboard while preserving generation type, streamed results, and cloud asset URLs.
* Added database migrations for the global provider record and for identifying existing Smart presentations correctly.

### Interface, exports, and packaging

* Improved provider connection states, mode-dialog positioning, dashboard action responsiveness, settings navigation, presentation deletion, and translation-overlay handling.
* Fixed export package integration, release versioning, and related backend tests.
* [Added an Enterprise overview to the source README](https://github.com/presenton/presenton/pull/825), covering Helm deployment, audit logs, centralized administration, and enterprise identity options.

## API and data compatibility

The self-hosted API remains under `/api/v1/`. This release adds administrator-controlled provider endpoints under `/api/v1/auth/presenton` for status, device authorization, polling, and logout. These routes support the application UI and do not replace normal browser, REST API, or MCP authentication.

Startup migrations create the global Presenton provider record and backfill the `smart` generation mode for presentations that already contain Smart HTML slides. Let migrations finish before starting concurrent instances.

<Warning>
  Connecting a Presenton account sends generation inputs and uploaded documents used by that provider to Presenton Cloud. Choose a local or separately configured provider when content must remain within your own infrastructure.
</Warning>

## Before upgrading

1. Back up `/app_data` and any external database.
2. Pull `ghcr.io/presenton/presenton:latest`, or select an explicit version or image digest for a controlled rollout.
3. Let database migrations finish before starting additional application instances.
4. Verify local administrator sign-in independently from the optional Presenton provider connection.
5. Test Standard and Smart generation, document uploads, streamed completion, local dashboard copies, assets, and both export formats.

## Full changelogs

* [Docker: compare `v0.9.6-beta...v0.9.7-beta`](https://github.com/presenton/presenton/compare/v0.9.6-beta...v0.9.7-beta)
* [Desktop: compare `electron-v0.9.5-beta...electron-v0.9.7-beta`](https://github.com/presenton/presenton/compare/electron-v0.9.5-beta...electron-v0.9.7-beta)


# Fonts
Source: https://docs.presenton.ai/user-guide/branding-and-design/brand-colors-and-fonts

Detect, resolve, and verify the fonts used by a custom presentation template.

Template Studio detects the fonts used in an uploaded PowerPoint presentation and helps make them available to the generated custom template.

Presenton provides fonts available through Google Fonts. If the PPTX uses a font that is not available, Template Studio lets you upload the font file manually.

<Note>
  This workflow manages fonts for custom templates. Template Studio does not provide color configuration during template creation; colors and other visual styling come from the uploaded PowerPoint design.
</Note>

## How font detection works

When you upload a filled `.pptx`, Template Studio reads the fonts referenced by its slides.

| Detection result                       | What happens                                                               |
| -------------------------------------- | -------------------------------------------------------------------------- |
| Font is available through Google Fonts | Presenton makes the font available automatically                           |
| Font is not available                  | Template Studio shows it as missing and provides an upload control         |
| Missing font is not uploaded           | A fallback font may change text width, wrapping, spacing, and slide layout |

## Review and resolve template fonts

<Steps>
  <Step title="Upload the PowerPoint presentation">
    Open **Templates**, start a new template, and upload the filled PPTX that contains your branded slide designs.
  </Step>

  <Step title="Start font detection">
    After the file is ready, continue to the font review step. Template Studio analyzes the fonts referenced by the presentation.
  </Step>

  <Step title="Review the detected fonts">
    Check the font list. Fonts available through Google Fonts are provided by Presenton. Fonts that cannot be found are marked for manual upload.

    <div>
      <p>Review detected fonts and identify missing files</p>

      <div>
        <img alt="Close-up of Template Studio font analysis showing detected fonts and a missing font upload control" />
      </div>
    </div>
  </Step>

  <Step title="Upload missing fonts">
    Use the upload control beside each missing font and select the corresponding font file from your computer.

    <div>
      <p>Upload a font that Presenton could not resolve</p>

      <div>
        <img alt="Close-up of Template Studio Font Management with an upload action for a missing font" />
      </div>
    </div>
  </Step>

  <Step title="Continue to slide preview">
    When the required fonts are available, continue to preview. Inspect titles, body text, line breaks, spacing, and alignment before creating the template.
  </Step>
</Steps>

## Choose the correct font file

* Upload the font family and weight requested by Template Studio.
* Use a font file that your organization is permitted to use and distribute.
* Keep regular, medium, semibold, bold, and italic variants available when the source deck uses them.
* Do not substitute a similarly named font without checking every affected slide.

<Warning>
  Font files are licensed assets. Confirm that your font license permits use in the deployment, generated presentations, and exported files.
</Warning>

## Verify font fidelity

After the template is generated:

1. Open its layouts and check short and long sample text.
2. Confirm headings and body text use the intended family and weight.
3. Look for unexpected wrapping, clipping, overflow, and alignment changes.
4. Generate a short Standard presentation with the custom template.
5. Export both PPTX and PDF and inspect them in the applications your audience will use.

<CardGroup>
  <Card title="Template creation" icon="wand-magic-sparkles" href="/user-guide/template-creation">
    Upload the source PPTX and create the reusable template.
  </Card>

  <Card title="Template Editing" icon="layer-group" href="/user-guide/editing-and-refining/template-editing">
    Test text behavior and character limits after generation.
  </Card>
</CardGroup>


# Templates
Source: https://docs.presenton.ai/user-guide/branding-and-design/templates

Turn your branded PowerPoint presentation into a reusable template for Standard presentations.

Templates let Presenton generate new presentations in an existing brand design. Use **Template Studio** to convert your own filled PowerPoint presentation into a reusable custom template.

Each slide in the uploaded PPTX can become a reusable layout. Presenton analyzes the slide structure, text fields, images, and other editable regions so new content can be placed into the same design.

<div>
  <p>Turn a branded PowerPoint presentation into a reusable template</p>

  <div>
    <img alt="Complete workflow for converting a PowerPoint presentation into a reusable template with Template Studio" />
  </div>
</div>

## What a branded template preserves

A well-prepared custom template helps generated presentations reuse:

* Branded slide layouts and composition
* Typography and text hierarchy
* Image, chart, table, and content regions
* Repeated visual elements and spacing
* Layouts for titles, sections, content, data, and closing slides

Templates control slide structure. Themes separately control presentation-wide colors, fonts, and logos.

| Branding need                                         | Use               |
| ----------------------------------------------------- | ----------------- |
| Reuse the layouts from an existing PowerPoint design  | Custom template   |
| Apply colors, fonts, and a logo across a presentation | Custom theme      |
| Start from a design supplied by Presenton             | Built-in template |

## Prepare the source PowerPoint

Upload a filled `.pptx` that represents the brand and includes the slide types you want Presenton to reuse.

* Include real sample content instead of empty placeholders.
* Add one or more distinct examples of each required layout type.
* Remove obsolete, confidential, and duplicate slides.
* Keep custom font files available for upload.
* Check that logos, images, and other brand assets are clear and correctly positioned.

<Warning>
  Do not use an empty PowerPoint master as the source. Template Studio learns from the content and structure of filled slides. Missing or near-duplicate examples can produce incomplete or unreliable layouts.
</Warning>

## Create the branded template

<Steps>
  <Step title="Open Template Studio">
    Open **Templates**, then select **Build Template** or **New Template**.
  </Step>

  <Step title="Upload the branded PPTX">
    Select **Upload PPTX File**, choose the source presentation, and wait for it to become **Ready**. Select **Get Started**.

    <div>
      <p>Upload a branded PowerPoint presentation</p>

      <div>
        <img alt="Close-up of Template Studio with an uploaded PowerPoint presentation ready for processing" />
      </div>
    </div>
  </Step>

  <Step title="Resolve the presentation fonts">
    Review the detected fonts and upload any missing font files. Correct fonts are required for reliable text measurement, wrapping, and layout fidelity.
  </Step>

  <Step title="Review the source slides">
    Inspect the thumbnails and slide preview. Confirm that the deck contains the branded layouts you want to reuse, then select **Create Template**.
  </Step>

  <Step title="Name and describe the template">
    Use a recognizable brand and use-case name. Add a description that explains when the template should be selected, then select **Create**.
  </Step>

  <Step title="Wait for layout generation">
    The template appears in the **Custom** library while Presenton converts the source slides into reusable layouts. Wait for generation to finish before using or editing it.
  </Step>
</Steps>

## Refine the generated layouts

After creation, open the template and review each generated layout in the Template Editor.

* Edit sample text and confirm the intended typography.
* Set realistic minimum and maximum character limits in **Schema**.
* Test Low, Medium, and High content density.
* Use **Re-Construct** if a slide is blank, incomplete, or incorrectly constructed.
* Check layout names and descriptions under **Layouts**.
* Save after reviewing the edited slides and metadata.

<CardGroup>
  <Card title="Template creation" icon="wand-magic-sparkles" href="/user-guide/template-creation">
    Follow the full Template Studio upload and creation workflow.
  </Card>

  <Card title="Template Editing" icon="layer-group" href="/user-guide/editing-and-refining/template-editing">
    Refine schemas, text behavior, reconstruction, and layout metadata.
  </Card>
</CardGroup>

## Validate the brand result

Before making the custom template the default choice for repeated work:

1. Generate a short Standard presentation with realistic content.
2. Confirm Presenton selects appropriate layouts for different slide purposes.
3. Check font rendering, text overflow, image placement, spacing, and logo treatment.
4. Export both PPTX and PDF.
5. Open the exports in the applications your audience will use.

<Tip>
  A smaller collection of distinct, dependable branded layouts is more useful than a large collection of near-duplicate slides.
</Tip>

<Note>
  Custom templates apply to Standard presentations. Cloud Smart presentations use Smart designs rather than Standard template layouts.
</Note>


# API Playground
Source: https://docs.presenton.ai/user-guide/cloud/api-playground

Configure a presentation request, test it, or copy the API code.

<Badge>Cloud only</Badge>

## Configure and run a request

<Steps>
  <Step title="Open API Playground">
    Select **API Playground** from the Presenton Cloud dashboard.
  </Step>

  <Step title="Choose the content format">
    <Tabs>
      <Tab title="Presentation Content">
        Use one prompt for the full presentation. Presenton decides how to divide the content across the selected number of slides.

        <div>
          <p>Write one prompt for the full deck</p>

          <div>
            <img alt="Close-up of API Playground using Presentation Content with one prompt for the full deck" />
          </div>
        </div>
      </Tab>

      <Tab title="Slide Specific Content">
        Use a separate content block for every slide. Add or remove slide blocks when you need exact control over the deck structure.

        <div>
          <p>Provide content for each slide</p>

          <div>
            <img alt="Close-up of API Playground using Slide Specific Content with separate content blocks for each slide" />
          </div>
        </div>
      </Tab>
    </Tabs>
  </Step>

  <Step title="Add content and generation options">
    Enter the presentation prompt or add content to each slide. Upload reference files when the request should use source material.

    For **Presentation Content**, choose the number of slides. Then select **Standard** for template-based layouts or **Smart** for content-driven composition.

    <div>
      <p>Choose the slide count for Presentation Content</p>

      <div>
        <img alt="Close-up of the API Playground slide-count menu for a Presentation Content request" />
      </div>
    </div>
  </Step>

  <Step title="Customize the request">
    Use only the settings required for the result you want.

    <AccordionGroup>
      <Accordion title="Generation Settings">
        Set content generation, tone, verbosity, image type, language, and export format.

        <div>
          <p>Set tone, verbosity, media, language, and export format</p>

          <div>
            <img alt="Close-up of API Playground Generation Settings with the tone menu open" />
          </div>
        </div>
      </Accordion>

      <Accordion title="Instruction">
        Choose an instruction preset or write custom instructions for the presentation.

        <div>
          <p>Add a preset or custom instruction</p>

          <div>
            <img alt="Close-up of the API Playground Instruction tab with custom presentation instructions" />
          </div>
        </div>
      </Accordion>

      <Accordion title="Included">
        Choose whether to include Markdown emphasis, a table of contents, a title slide, and user information.

        <div>
          <p>Choose the optional presentation sections</p>

          <div>
            <img alt="Close-up of the API Playground Included tab with optional presentation sections" />
          </div>
        </div>
      </Accordion>
    </AccordionGroup>
  </Step>

  <Step title="Generate or get code">
    Select **Generate** to run the request and review the presentation in Presenton.

    Select **Get Code** when the configuration is ready to use in your application or automation. Test with **Generate** first when you want to confirm the output before integrating it.

    <div>
      <p>Follow the complete Playground workflow</p>

      <div>
        <img alt="Complete API Playground workflow from configuration to Generate and Get Code" />
      </div>
    </div>
  </Step>
</Steps>


# Edit PPTX with AI
Source: https://docs.presenton.ai/user-guide/cloud/edit-pptx-with-ai

Import an existing PowerPoint presentation and edit it with AI.

<Badge>Cloud only</Badge>

## Import and edit

<Steps>
  <Step title="Upload the PPTX">
    From the dashboard, click **Edit PPTX with AI**. Select or drag in the PPTX you want to edit.

    <div>
      <p>Select or drag in the PowerPoint file</p>

      <div>
        <img alt="Uploading a PPTX from the Presenton Import Presentation page" />
      </div>
    </div>
  </Step>

  <Step title="Check fonts">
    After the file uploads, click **Check Fonts**.

    <div>
      <p>Check the fonts used in the uploaded presentation</p>

      <div>
        <img alt="Uploaded PPTX with the Check Fonts button" />
      </div>
    </div>
  </Step>

  <Step title="Manage fonts">
    Review **Available Fonts** and **Missing Fonts**. If a font is missing, click **Upload** and select its font file.

    <div>
      <p>Review available and missing fonts</p>

      <div>
        <img alt="Font Management showing available fonts and one missing font" />
      </div>
    </div>

    <div>
      <p>Select the matching font file when a font is missing</p>

      <div>
        <img alt="File picker selecting the missing Arial Regular font file" />
      </div>
    </div>

    <Note>If every font is already available, continue without uploading a font file.</Note>
  </Step>

  <Step title="Import the presentation">
    Confirm that all fonts are ready, then click **Import Presentation**.

    <div>
      <p>Import after all required fonts are ready</p>

      <div>
        <img alt="Close-up of Font Management confirming the uploaded font and showing Import Presentation" />
      </div>
    </div>
  </Step>

  <Step title="Edit with AI">
    Wait for the editable deck to open. Enable **Select Edit** for direct changes or use the **AI Assistant** to update slide content and design.

    <div>
      <p>Edit the imported presentation directly or with AI</p>

      <div>
        <img alt="Imported PowerPoint presentation open in the Presenton Editor with Select Edit and AI Assistant" />
      </div>
    </div>
  </Step>
</Steps>


# Create a presentation
Source: https://docs.presenton.ai/user-guide/create-new-presentation

Create a presentation in Presenton Cloud or open-source Presenton.

## Create a presentation

Choose **Cloud** for Presenton Cloud or **Open-source** for your local or self-hosted installation. Each tab follows the workflow from prompt to generated presentation.

## Watch the workflow

<video>
  Your browser does not support the video tag.
</video>

## Generation essentials

| Decision          | Guidance                                                                                                                    |
| ----------------- | --------------------------------------------------------------------------------------------------------------------------- |
| Presentation type | Use **Standard** for reusable template layouts. Choose **Smart** when available and the design should adapt to the content. |
| Prompt            | Name the audience, desired outcome, scope, and facts that must remain unchanged.                                            |
| Source material   | Attach only relevant, authoritative documents, spreadsheets, images, or presentations.                                      |
| Controls          | Set the slide count, language, tone, verbosity, and structural options that carry a real requirement.                       |
| Outline           | Correct missing content, weak sequencing, unsupported claims, and unnecessary slides before generation.                     |

<Tip>
  Use the prompt to explain what to create and attachments to provide evidence. For example: `Create a seven-slide executive update from the attached report. Preserve every reported figure and end with three decisions.`
</Tip>

<Tabs>
  <Tab title="Cloud">
    <Steps>
      <Step title="Open Create new Presentation">
        Select **Create new Presentation** from the Cloud dashboard.

        <div>
          <p>Open the Cloud generator</p>

          <div>
            <img alt="Close-up of the Presenton Cloud generator with prompt, attachments, controls, and Get Started" />
          </div>
        </div>
      </Step>

      <Step title="Choose Standard or Smart">
        Choose **Standard** for template-based layouts or **Smart** for content-driven composition.

        <div>
          <p>Switch between Standard and Smart</p>

          <div>
            <img alt="Selecting Standard and Smart presentation modes" />
          </div>
        </div>
      </Step>

      <Step title="Set the slides and language">
        Choose **Auto slides** or a fixed count, then select the output language.

        <div>
          <p>Choose Auto slides or a fixed slide count</p>

          <div>
            <img alt="Close-up of the Cloud slide-count control and fixed slide options" />
          </div>
        </div>

        <div>
          <p>Select the presentation language</p>

          <div>
            <img alt="Close-up of the Cloud output-language menu" />
          </div>
        </div>
      </Step>

      <Step title="Add the prompt and files">
        Describe the presentation you want. Attach reference files when Presenton should use specific source material.

        <div>
          <p>Describe the presentation you want</p>

          <div>
            <img alt="Close-up of the Cloud prompt and attachment areas with a presentation topic entered" />
          </div>
        </div>

        <div>
          <p>Attach files beside the prompt</p>

          <div>
            <img alt="Reference file attached beside the Cloud prompt" />
          </div>
        </div>
      </Step>

      <Step title="Review Advanced settings">
        Set tone, verbosity, title slide, table of contents, web search, or additional instructions when needed.

        <div>
          <p>Adjust only the settings you need</p>

          <div>
            <img alt="Close-up of Advanced settings for tone, verbosity, structure, web search, and instructions" />
          </div>
        </div>
      </Step>

      <Step title="Get started">
        Select **Get Started**, review the outline, and choose the design before generating the presentation.

        <div>
          <p>Review the outline before generating slides</p>

          <div>
            <img alt="Close-up of a generated presentation outline ready for review" />
          </div>
        </div>

        After generation, the presentation opens in the editor.

        <div>
          <p>Continue in the Presenton Editor</p>

          <div>
            <img alt="Generated Cloud presentation open in the Presenton Editor" />
          </div>
        </div>
      </Step>
    </Steps>
  </Tab>

  <Tab title="Open-source">
    Complete [open-source onboarding](/user-guide/onboarding#open-source) first.

    <Steps>
      <Step title="Open the generator">
        Start a new presentation and confirm the configured provider shown above the prompt.

        <div>
          <p>Open the Generate page</p>

          <div>
            <img alt="Close-up of the open-source Generate page with Standard mode, prompt, attachments, and Get Started" />
          </div>
        </div>
      </Step>

      <Step title="Configure the presentation">
        Keep **Auto slides** or choose a slide count, select the language, and open **Advanced settings** when needed.

        <div>
          <p>Generation controls above the prompt</p>

          <div>
            <img alt="Open-source controls for Standard mode, slide count, language, and advanced settings" />
          </div>
        </div>

        <div>
          <p>Choose Auto slides or a fixed slide count</p>

          <div>
            <img alt="Close-up of the open-source slide-count menu with fixed slide options" />
          </div>
        </div>

        <div>
          <p>Select the presentation language</p>

          <div>
            <img alt="Close-up of the open-source language menu with Auto and supported output languages" />
          </div>
        </div>

        <div>
          <p>Review Advanced settings when needed</p>

          <div>
            <img alt="Close-up of open-source Advanced Settings with instructions, tone, verbosity, table of contents, and title slide" />
          </div>
        </div>
      </Step>

      <Step title="Add the prompt and files">
        Enter a prompt, upload reference files, or use both.

        <div>
          <p>Prompt and attached source file ready for generation</p>

          <div>
            <img alt="Open-source Generate page with the prompt area and an attached PDF source document" />
          </div>
        </div>
      </Step>

      <Step title="Get started">
        Select **Get Started**, choose a template, review the outline, and generate the presentation.

        Use **Built-in** for templates provided by Presenton. Use **Custom** when you want to create or reuse your own template.

        <div>
          <p>Choose a Built-in template from Presenton</p>

          <div>
            <img alt="Close-up of the open-source built-in template gallery" />
          </div>
        </div>

        <div>
          <p>Choose or build your own Custom template</p>

          <div>
            <img alt="Close-up of the open-source custom template area with Build Template and a saved custom template" />
          </div>
        </div>

        [Follow the complete template creation workflow](/user-guide/template-creation)

        <div>
          <p>Review and edit the outline with AI</p>

          <div>
            <img alt="Open-source outline review with AI editing before generating the presentation" />
          </div>
        </div>

        After generation, the presentation opens in the editor.

        <div>
          <p>Continue in the Presenton Editor</p>

          <div>
            <img alt="Generated open-source presentation open in the Presenton Editor" />
          </div>
        </div>
      </Step>
    </Steps>
  </Tab>
</Tabs>

## Verify source-based presentations

* Compare important names, dates, claims, and figures with the original files.
* Recalculate totals, percentages, and changes shown in tables or charts.
* Confirm units, reporting periods, category labels, and data sources.
* Review image relevance, cropping, and usage rights.
* Inspect the exported PPTX or PDF for overflow, clipping, and layout changes.

<CardGroup>
  <Card title="Refine the presentation" icon="pen-to-square" href="/user-guide/presentation-editor">
    Choose direct Canvas editing or the AI assistant for the changes you still need.
  </Card>

  <Card title="Export the result" icon="file-export" href="/user-guide/managing-presentations/export-presentations">
    Download the verified presentation as PPTX or PDF.
  </Card>
</CardGroup>


# Design creation
Source: https://docs.presenton.ai/user-guide/design-creation

Turn a PowerPoint presentation into a reusable custom design for Smart presentations.

Use **Design Studio** to convert a filled PowerPoint presentation into a reusable custom design for Smart mode. Presenton analyzes the source slides, resolves their fonts, and generates a design that Smart presentations can use with flexible content.

<Note>
  Design creation is a Presenton Cloud Smart-mode workflow. For fixed Standard layouts, use [Template creation](/user-guide/template-creation).
</Note>

## Designs and templates

| Reusable asset | Presentation mode | Best for                                                                       |
| -------------- | ----------------- | ------------------------------------------------------------------------------ |
| Design         | Smart             | Flexible slide composition based on the source presentation's visual direction |
| Template       | Standard          | Predictable layouts converted from individual source slides                    |

<Tip>
  Upload a filled PPTX with representative content and a consistent visual system. An empty master or slides made only from placeholders do not give Design Studio enough information to analyze the design reliably.
</Tip>

## Create a custom design

<Steps>
  <Step title="Open generation and select Smart mode">
    Start a new presentation. Open the mode selector and choose **Smart**.

    <div>
      <p>Open the presentation generator</p>

      <div>
        <img alt="Presenton Generate page with the presentation mode selector set to Standard" />
      </div>
    </div>

    <div>
      <p>Select Smart for flexible design-based generation</p>

      <div>
        <img alt="Mode selection dialog comparing fixed Standard layouts with flexible Smart layouts" />
      </div>
    </div>
  </Step>

  <Step title="Open Design Studio">
    In **Choose a design**, select **Create new design**. You can start from the creation card, the button beside the section heading, or the empty state under **Your designs**.

    <Tabs>
      <Tab title="Default designs">
        <div>
          <p>Built-in Smart designs and the Create new design action</p>

          <div>
            <img alt="Smart generation page showing built-in designs and Create new design" />
          </div>
        </div>
      </Tab>

      <Tab title="Your designs">
        <div>
          <p>Create the first custom design from the empty state</p>

          <div>
            <img alt="Your designs tab with no custom designs and a Create new design button" />
          </div>
        </div>
      </Tab>
    </Tabs>
  </Step>

  <Step title="Upload the source PPTX">
    In **Design Studio**, select **Upload PPTX File** and choose the filled PowerPoint presentation whose visual design you want to reuse. The displayed limits are PPTX only, up to 100 MB, with an estimated five-minute generation time.

    <div>
      <p>Upload a PowerPoint presentation to Design Studio</p>

      <div>
        <img alt="Design Studio upload screen with a Select a PPTX file action" />
      </div>
    </div>
  </Step>

  <Step title="Check the detected fonts">
    After the file appears, select **Check Fonts**. Presenton supplies fonts it can resolve and identifies any font files that must be uploaded manually.

    <div>
      <p>Uploaded PPTX ready for font analysis</p>

      <div>
        <img alt="Design Studio with an uploaded PPTX and the Check Fonts action" />
      </div>
    </div>

    <div>
      <p>Continue after all required fonts are available</p>

      <div>
        <img alt="Design Studio Font Management showing all fonts ready and Continue to Preview" />
      </div>
    </div>
  </Step>

  <Step title="Preview the source slides">
    Select **Continue to Preview**. Review the detected slides and confirm that typography, images, spacing, and the overall design match the source PPTX.

    <div>
      <p>Review the source slides before generating the design</p>

      <div>
        <img alt="Design Studio Slide Preview showing the uploaded presentation and Generate Design action" />
      </div>
    </div>
  </Step>

  <Step title="Name and generate the design">
    Select **Generate Design**, enter a clear name, and confirm generation. Use a name that identifies the brand, team, or intended presentation type.

    <div>
      <p>Name the reusable Smart design</p>

      <div>
        <img alt="Name Your Design dialog with a design name and Generate Design action" />
      </div>
    </div>
  </Step>

  <Step title="Wait for asynchronous generation">
    Design generation runs asynchronously. You can stay on the page or select **Go to Designs**. Presenton displays the request status and sends an email when the design is ready.

    <div>
      <p>Design generation request accepted for asynchronous processing</p>

      <div>
        <img alt="Design Generation Started dialog showing processing status, request ID, and email notification" />
      </div>
    </div>
  </Step>
</Steps>

## Find and use the design

Open **Designs** from the dashboard. **Default** contains designs provided by Presenton; **Your designs** contains designs generated from your PPTX files.

<Tabs>
  <Tab title="Default">
    <div>
      <p>Built-in designs supplied by Presenton</p>

      <div>
        <img alt="Designs library Default tab with built-in Smart designs" />
      </div>
    </div>
  </Tab>

  <Tab title="Your designs">
    <div>
      <p>Generated custom design under Your designs</p>

      <div>
        <img alt="Designs library Your designs tab with a generated custom design and Use action" />
      </div>
    </div>
  </Tab>
</Tabs>

To create a Smart presentation with the design:

<Steps>
  <Step title="Select the custom design">
    Start a Smart presentation, enter the prompt and optional attachments, open **Your designs**, and select the custom design. Then select **Get Started**.

    <div>
      <p>Select a custom design for Smart generation</p>

      <div>
        <img alt="Smart generation page with a custom design selected under Your designs" />
      </div>
    </div>
  </Step>

  <Step title="Wait for the outline">
    Presenton analyzes the prompt and sources, optionally performs web search, and builds the presentation outline.

    <div>
      <p>Smart presentation outline generation in progress</p>

      <div>
        <img alt="Generating outline dialog showing request, analysis, and web-search progress" />
      </div>
    </div>
  </Step>

  <Step title="Review the outline">
    Review the title, slide order, content, and supporting points. Reorder or remove slides where required, then select **Generate Presentation**.

    <div>
      <p>Review Smart presentation content before generation</p>

      <div>
        <img alt="Outline and Content page with generated slide sections and Generate Presentation" />
      </div>
    </div>
  </Step>

  <Step title="Review the generated presentation">
    Check every slide for content accuracy, layout quality, image relevance, and text overflow. Use the editor and AI Assistant for refinements, then export the verified presentation.

    <div>
      <p>Smart presentation generated with the custom design</p>

      <div>
        <img alt="Generated Smart presentation open in the Presenton editor with slide thumbnails and AI Assistant" />
      </div>
    </div>
  </Step>
</Steps>

## Verify a new design

* Generate a short presentation with varied slide purposes.
* Check that the visual direction remains consistent across slides.
* Confirm all intended fonts render correctly.
* Review both short and long content for overflow or weak spacing.
* Export PPTX and PDF and inspect both files before using the design for repeated work.

<CardGroup>
  <Card title="Template creation" icon="layer-group" href="/user-guide/template-creation">
    Use Template Studio when you need fixed, reusable layouts for Standard presentations.
  </Card>

  <Card title="Refine a generated presentation" icon="pen-to-square" href="/user-guide/presentation-editor">
    Continue with Canvas editing or the AI assistant after generating with the design.
  </Card>
</CardGroup>


# Using the AI assistant
Source: https://docs.presenton.ai/user-guide/editing-and-refining/ai-assistant

Send one focused request for the active slide and review the result.

Use AI when the change is easier to describe than to build manually. Keep the active slide in scope, request one result, and review the completed edit before sending another prompt.

<div>
  <p>Add a slide and request one focused change with AI</p>

  <div>
    <video>
      Your browser does not support the video tag.
    </video>
  </div>
</div>

<Steps>
  <Step title="Confirm the slide">
    Open the target slide and check the slide chip in the AI composer.
  </Step>

  <Step title="Describe one result">
    Enter a focused request, such as `Add a heading about the content`.
  </Step>

  <Step title="Send and wait">
    Submit the prompt and allow the change to finish.
  </Step>

  <Step title="Review the slide">
    Check the new content, its placement, and the objects that should remain unchanged.
  </Step>
</Steps>

<CardGroup>
  <Card title="Editing with prompts" icon="wand-magic-sparkles" href="/user-guide/editing-and-refining/editing-with-prompts">
    Write a clear target, action, and constraint.
  </Card>

  <Card title="Context-aware editing" icon="crosshairs" href="/user-guide/editing-and-refining/context-aware-editing">
    Confirm the slide scope and Follow AI mode.
  </Card>

  <Card title="Presentation context and memory" icon="brain" href="/user-guide/editing-and-refining/presentation-context-and-memory">
    See which context behavior still needs verified product media.
  </Card>
</CardGroup>


# Blocks and layout
Source: https://docs.presenton.ai/user-guide/editing-and-refining/canvas/block-editing

Find and add reusable content blocks.

Blocks are reusable slide sections with one or more layout variants.

This focused walkthrough shows only the relevant workflow: open **Blocks**, choose a reusable pattern or **Use Template**, select a variant, and review the inserted layout.

<video>
  Your browser does not support the video tag.
</video>

<div>
  <p>Browse block families beside the active slide</p>

  <div>
    <img alt="Presentation editor with the Blocks panel open and reusable block families listed" />
  </div>
</div>

## Add a block

<Steps>
  <Step title="Open Blocks">
    Select **Blocks** in the editor rail.
  </Step>

  <Step title="Find the content pattern">
    Search by purpose, such as `metadata`, or browse the available block families.
  </Step>

  <Step title="Review layout variants">
    Expand the layout count on a block card and choose the variant that matches the slide.
  </Step>

  <Step title="Check the result">
    Confirm that the inserted content fits the slide and follows the surrounding design.
  </Step>
</Steps>

<div>
  <p>Search result for a Metadata Card with two layouts</p>

  <div>
    <img alt="Blocks panel showing a metadata search result and a Metadata Card with two layouts" />
  </div>
</div>

<Card title="Edit individual elements" icon="arrows-up-down-left-right" href="/user-guide/editing-and-refining/canvas/drag-and-drop">
  Move or resize an inserted element on the canvas.
</Card>


# Move, resize, and rotate
Source: https://docs.presenton.ai/user-guide/editing-and-refining/canvas/drag-and-drop

Transform a selected canvas element.

Select an element on the slide to reveal its canvas handles and editing controls. Before moving it, note its alignment, spacing, size, and relationship with nearby text or visual elements so the revised layout remains balanced.

<video>
  Your browser does not support the video tag.
</video>

<Steps>
  <Step title="Select the element">
    Click the object that should change and confirm that only the intended element is selected. If several objects behave as one unit, check whether they are grouped before transforming them.
  </Step>

  <Step title="Transform it">
    Drag the object to move it. Use the visible handles to resize or rotate it, making one controlled adjustment at a time. Resize images proportionally when their original aspect ratio should remain unchanged.
  </Step>

  <Step title="Review the slide">
    Check overlap, margins, alignment, spacing, text wrapping, slide boundaries, and the relationship with nearby content. Preview the complete slide rather than judging the changed element in isolation.
  </Step>
</Steps>

<Tip>
  Make one transform at a time and compare the result with the surrounding layout. Verify important changes in an exported PPTX or PDF when exact placement, cropping, or font rendering matters.
</Tip>


# Groups and layers
Source: https://docs.presenton.ai/user-guide/editing-and-refining/canvas/group-and-ungroup

Group selected objects or separate a group for individual editing.

Group related objects when they should move and resize as one composition. Ungroup them when an individual object needs a separate change.

<div>
  <p>Select multiple objects and choose Group</p>

  <div>
    <img alt="Two selected text objects with the Group action available" />
  </div>
</div>

<Steps>
  <Step title="Select multiple objects">
    Select the objects that should behave as one composition. The selection count appears above the canvas.
  </Step>

  <Step title="Group the selection">
    Choose **Group** or use the displayed keyboard shortcut.
  </Step>

  <Step title="Edit the group">
    Move, resize, or rotate the grouped composition and review its relationship with nearby content.
  </Step>
</Steps>

<div>
  <p>Select a grouped composition and choose Ungroup</p>

  <div>
    <img alt="A grouped text composition selected with the Ungroup action available" />
  </div>
</div>

<Steps>
  <Step title="Select the group">
    Select the grouped composition to reveal its object actions.
  </Step>

  <Step title="Ungroup it">
    Choose **Ungroup** to separate the composition into individually selectable objects.
  </Step>

  <Step title="Edit an individual object">
    Select the required object, make the change, and check the surrounding layout.
  </Step>
</Steps>

<Note>
  The supplied captures verify **Group** and **Ungroup**. They do not show layer-order controls such as **Bring forward** or **Send backward**.
</Note>

For a single object, use:

<CardGroup>
  <Card title="Move, resize, and rotate" icon="arrows-up-down-left-right" href="/user-guide/editing-and-refining/canvas/drag-and-drop">
    Transform one selected object.
  </Card>

  <Card title="Shapes and lines" icon="shapes" href="/user-guide/editing-and-refining/canvas/shape-editing">
    Add a verified element from the Elements panel.
  </Card>
</CardGroup>


# Images and icons
Source: https://docs.presenton.ai/user-guide/editing-and-refining/canvas/image-editing

Add and edit image content.

## Add an image layout

Open **Images**, then choose **Image**, **Image + Text**, or **Image Grid**.

<video>
  Your browser does not support the video tag.
</video>

<div>
  <p>Image layouts available from the editor rail</p>

  <div>
    <img alt="Images panel with Image, Image plus Text, and Image Grid options" />
  </div>
</div>

## Edit an image

<div>
  <p>Add an image, replace its content, and adjust its presentation</p>

  <div>
    <video>
      Your browser does not support the video tag.
    </video>
  </div>
</div>

1. Select the image element.
2. Use the image controls shown for the selection to replace or adjust it.
3. Resize or reposition the frame when needed.
4. Confirm the subject remains visible and the image does not cover nearby content.

## Edit an icon

Select an icon to change its color. Choose **Change Icon** to search for a more appropriate symbol, compare the available weights, and apply the replacement.

<div>
  <p>Recolor and replace an icon</p>

  <div>
    <video>
      Your browser does not support the video tag.
    </video>
  </div>
</div>


# Shapes and lines
Source: https://docs.presenton.ai/user-guide/editing-and-refining/canvas/shape-editing

Add, position, and style shapes, arrows, and connectors.

Open **Elements** to add a **Rectangle**, **Circle**, **Ellipse**, **Triangle**, **Diamond**, **Pentagon**, **Hexagon**, **Arrow**, or **Line**. This walkthrough shows the complete workflow: position a shape, refine its appearance, and format a connector.

<video>
  Your browser does not support the video tag.
</video>

<Steps>
  <Step title="Add and position the element">
    Select the required shape, arrow, or line from **Elements**. Drag the selection handles to resize it, then move it into place on the canvas.
  </Step>

  <Step title="Style a shape">
    Use the contextual controls to set the fill and border. Adjust opacity, corner radius, and shadow when they support the design.
  </Step>

  <Step title="Format a line or connector">
    Drag the endpoints into place, then choose the stroke, thickness, and end style from the toolbar.
  </Step>

  <Step title="Review the composition">
    Check the slide at its final size. Keep connectors easy to follow, maintain consistent styling, and make sure no element obscures text or data.
  </Step>
</Steps>

<Card title="Transform canvas elements" icon="arrows-up-down-left-right" href="/user-guide/editing-and-refining/canvas/drag-and-drop">
  Watch the verified resize, rotate, and reposition workflow.
</Card>


# Tables and charts
Source: https://docs.presenton.ai/user-guide/editing-and-refining/canvas/table-editing

Add and edit structured data on a slide.

## Add structured content

Open the appropriate editor rail, add one item at a time, and keep it selected while configuring its content and placement. This walkthrough shows the complete flow for adding a chart and a table, then editing them directly on the canvas.

<video>
  Your browser does not support the video tag.
</video>

<Tabs>
  <Tab title="Tables">
    Open **Tables** and select **Simple Table**.

    <div>
      <p>Simple Table available from the editor rail</p>

      <div>
        <img alt="Tables panel with the Simple Table option" />
      </div>
    </div>

    <div>
      <p>Edit table cells directly on the slide</p>

      <div>
        <video>
          Your browser does not support the video tag.
        </video>
      </div>
    </div>

    Select the table, edit the required cells, and verify every label and value against the source.
  </Tab>

  <Tab title="Charts">
    Open **Charts** and choose the form that matches the data.

    <div>
      <p>Chart and infographic types available from the editor rail</p>

      <div>
        <img alt="Charts panel with bar, line, pie, area, donut, scatter, radar, polar area, progress bar, and gauge options" />
      </div>
    </div>

    <div>
      <p>Add a chart and edit its data and presentation</p>

      <div>
        <video>
          Your browser does not support the video tag.
        </video>
      </div>
    </div>

    Use a bar chart for category comparison, a line or area chart for change over time, and a table when exact values matter more than the pattern.
  </Tab>
</Tabs>

<Warning>
  Visual editing does not validate data. Recheck units, periods, categories, totals, and plotted values before export.
</Warning>


# Text editing
Source: https://docs.presenton.ai/user-guide/editing-and-refining/canvas/text-editing

Add text blocks, rewrite copy, and format text on the slide.

Open **Texts** to add a **Title Block**, **Subtitle**, **Bullet List**, **Order List**, **List Item**, **Quote**, or **Body Text**. The walkthrough shows the complete workflow: write the copy, arrange the text blocks, then apply typography controls.

<video>
  Your browser does not support the video tag.
</video>

## Add a text block

1. Choose a text block from **Texts**.
2. Enter the required copy.
3. Position the new text without covering existing content.

## Edit existing text

1. Select a text box and rewrite its copy directly on the canvas.
2. Drag or resize the box to improve spacing and alignment.
3. Select the required text and use the floating toolbar to change its color, emphasis, size, or alignment.
4. Review hierarchy, wrapping, contrast, and overflow across the complete slide.

<Card title="Rewrite with a prompt" icon="wand-magic-sparkles" href="/user-guide/editing-and-refining/editing-with-prompts">
  Use a focused AI request when the wording—not only the formatting—needs to change.
</Card>


# Context-aware editing
Source: https://docs.presenton.ai/user-guide/editing-and-refining/context-aware-editing

Target an AI change to the selected slide or canvas element.

Select the content first, then prompt the assistant. Presenton adds the active slide and selected canvas element to the composer as context chips, making the intended scope visible before the request is sent.

<video>
  <track label="English" />

  Your browser does not support the video tag.
</video>

## Edit the selected content

1. Open the slide you want to change.
2. Select the text, image, shape, or other canvas element.
3. Check the chips above the prompt. The recording shows both **Slide 1** and the selected ungrouped component.
4. Describe the requested change and send the prompt.
5. Review the edited element and the rest of the slide before continuing.

The example changes the selected cover title to **SEO Report 2026**. The assistant reports the completed edit in the same conversation.

<div>
  <p>The slide chip makes the current prompt scope visible</p>

  <div>
    <img alt="Assistant composer showing Slide 1 as the selected scope" />
  </div>
</div>

## Check scope before every prompt

* Remove a chip when that slide or element should not be part of the request.
* Name the intended object in the prompt when the change must be precise.
* Restate anything that must remain unchanged.
* Verify the visible result; a context chip guides the request but does not replace review.


# Editing with prompts
Source: https://docs.presenton.ai/user-guide/editing-and-refining/editing-with-prompts

Write focused editing requests that are easy to review.

The verified workflow uses one direct request. Keep each prompt focused on one related outcome, identify the active slide or selected content, and state any facts, values, or visual elements that must remain unchanged:

```text theme={null}
Add a heading about the content.
```

## Write a focused request

| Include | Purpose                                                                                                                      |
| ------- | ---------------------------------------------------------------------------------------------------------------------------- |
| Target  | Name the active slide, selected element, or specific content that should change so the edit stays within the intended scope. |
| Action  | State one verifiable result: add, rewrite, shorten, remove, reorganize, or change the tone for a named audience.             |
| Keep    | Identify facts, figures, citations, brand terms, formatting, or objects that must remain unchanged.                          |

## Review before the next prompt

1. Confirm that the requested content was added, removed, or changed exactly once.
2. Check its position, hierarchy, text wrapping, and relationship to nearby elements.
3. Verify that protected facts, values, objects, and brand requirements did not change.
4. Compare the result with the original instruction and correct any unrelated changes.
5. Send the next request only after the current result is accurate and visually coherent.

<Tip>
  Keep one prompt to one related outcome. Smaller requests are easier to verify, correct, and reverse without affecting unrelated slide content.
</Tip>

<Card title="Choose the editing scope" icon="crosshairs" href="/user-guide/editing-and-refining/context-aware-editing">
  Confirm that the assistant is attached to the intended slide and selected element before describing the requested change.
</Card>


# Presentation context and memory
Source: https://docs.presenton.ai/user-guide/editing-and-refining/presentation-context-and-memory

Use visible selection and conversation history as prompt context.

The assistant keeps two useful kinds of context visible while you work in the current chat:

* **Selection context:** chips identify the active slide and selected canvas element.
* **Conversation context:** recent prompts and assistant results remain in the panel above the composer.

<video>
  <track label="English" />

  Your browser does not support the video tag.
</video>

The close-up follows one request from its selected scope through the assistant response. It does not imply permanent memory across new chats, reopened presentations, browsers, or deployments.

## Read the visible context

Before sending a follow-up prompt:

1. Check the slide and element chips.
2. Read the latest prompt and assistant result.
3. Restate critical facts, source requirements, and anything that must not change.
4. Review the result on the canvas.

<div>
  <p>Current-chat history and selected scope in the assistant panel</p>

  <div>
    <img alt="AI assistant panel showing recent prompts, assistant responses, Slide 1, and a selected component chip" />
  </div>
</div>

## Start with a clean context

Select **New chat** when you are moving to an unrelated task or do not want the next request to build on the visible conversation. Then select the intended slide or element again and confirm the new scope chips before prompting.


# Slide Editing
Source: https://docs.presenton.ai/user-guide/editing-and-refining/slide-editing

Add slides with AI or templates, then duplicate, reorder, or delete them.

Use the slide rail to select a slide and the controls below the canvas to add or manage slides. You can start with a blank slide, choose a template, generate a slide with AI, or organize the slides already in your deck.

## Watch the slide-editing workflow

This walkthrough shows how to generate a slide with AI, apply a template, and open the slide actions menu.

<video>
  Your browser does not support the video tag.
</video>

## Add a slide

<Steps>
  <Step title="Choose where to add the slide">
    Select the slide that should come before the new slide. Its thumbnail is highlighted in the slide rail.
  </Step>

  <Step title="Choose how to create it">
    Use one of the controls below the active slide:

    | Control          | Use it when                                                     |
    | ---------------- | --------------------------------------------------------------- |
    | **Blank**        | You want an empty canvas and will add the content yourself.     |
    | **Use Template** | You want to start from an existing slide layout.                |
    | **AI slide**     | You want Presenton to generate the slide from a focused prompt. |
  </Step>

  <Step title="Review the new slide">
    Check the generated or selected layout, update its content, and confirm that it appears in the correct position in the slide rail.
  </Step>
</Steps>

<Tip>
  For AI generation, describe one slide and its intended result. For example: `Create a ranking slide with a keyword-position chart and three SEO takeaways.`
</Tip>

## Duplicate, reorder, or delete a slide

Open the three-dot menu below the active slide to access its management actions.

<div>
  <p>Slide actions menu</p>

  <div>
    <img alt="Slide actions menu showing Duplicate Slide, Move Up, Move Down, and Delete Slide above the Blank, Use Template, AI slide, and three-dot controls" />
  </div>
</div>

| Action              | Result                                            |
| ------------------- | ------------------------------------------------- |
| **Duplicate Slide** | Creates a copy of the active slide.               |
| **Move Up**         | Moves the slide one position earlier in the deck. |
| **Move Down**       | Moves the slide one position later in the deck.   |
| **Delete Slide**    | Removes the active slide from the deck.           |

After moving or duplicating a slide, review the slide rail to confirm the sequence. After deleting a slide, confirm that the intended slide was removed before continuing.

## Continue editing

<CardGroup>
  <Card title="Build slide content" icon="object-group" href="/user-guide/editing-and-refining/canvas-editor">
    Add and edit content directly on the slide.
  </Card>

  <Card title="Create content with AI" icon="sparkles" href="/user-guide/editing-and-refining/ai-assistant">
    Request one focused change for the active slide.
  </Card>
</CardGroup>


# Template Editing
Source: https://docs.presenton.ai/user-guide/editing-and-refining/template-editing

Edit a saved template's text behavior, schema, reconstruction, and layout metadata.

Template Editing starts **after** [Template Creation](/user-guide/template-creation). Use it to test and refine how a saved template behaves when Presenton generates new content.

## Watch the template-editing workflow

This narrated walkthrough covers editing template text and schema limits, reconstructing a slide, checking layout metadata, and saving the refined template.

<video>
  Your browser does not support the video tag.
</video>

## Editing workflow

<Steps>
  <Step title="Select a slide">
    Choose a template slide from the thumbnail rail.
  </Step>

  <Step title="Test its text behavior">
    Edit text on the canvas or adjust its schema content and character limits.
  </Step>

  <Step title="Reconstruct when required">
    Rebuild a slide when its template construction or rendering is incomplete.
  </Step>

  <Step title="Review layout metadata">
    Open **Layouts** to inspect slide IDs and descriptions.
  </Step>

  <Step title="Save">
    Review the reconstructed slide and select **Save**.
  </Step>
</Steps>

## Edit text and schema behavior

<div>
  <p>Select template slides, edit canvas text, and verify the schema beside the slide</p>

  <div>
    <video>
      Your browser does not support the video tag.
    </video>
  </div>
</div>

<Tabs>
  <Tab title="Canvas text">
    1. Select a text element on the template slide.
    2. Replace its sample content.
    3. Use the visible text toolbar when the template typography or text box needs adjustment.
    4. Check the updated slide at the expected content length.
  </Tab>

  <Tab title="Schema">
    1. Open **Schema** and expand the required text field.
    2. Update **Content** with representative sample text.
    3. Set **Min Chars** and **Max Chars** to the expected content range.
    4. Test **Low**, **Medium**, and **High** content density to see how the layout behaves at different text lengths.
  </Tab>
</Tabs>

<div>
  <p>Schema controls for content density, type, character bounds, and sample content</p>

  <div>
    <img alt="Schema Editor showing Low, Medium, and High content density plus a Main Title string with minimum characters, maximum characters, and sample content" />
  </div>
</div>

<Tip>
  Use realistic short and long samples. The goal is to confirm that generated text remains readable without breaking the intended layout.
</Tip>

## Reconstruct a slide

Use **Re-Construct** when a slide is blank, partially rendered, or has a template-construction issue.

<div>
  <p>Slide actions</p>

  <div>
    <img alt="Re-Construct and Copy ID controls below the active template slide" />
  </div>
</div>

<Tabs>
  <Tab title="Start reconstruction">
    <div>
      <p>Start Re-Construct and wait while the canvas rebuilds</p>

      <div>
        <video>
          Your browser does not support the video tag.
        </video>
      </div>
    </div>
  </Tab>

  <Tab title="Review the result">
    <div>
      <p>The reconstructed slide returns to the canvas with a completion message</p>

      <div>
        <video>
          Your browser does not support the video tag.
        </video>
      </div>
    </div>
  </Tab>
</Tabs>

After reconstruction, verify the slide content, text bounds, object placement, and schema before saving.

## Inspect Deck Layouts

Open **Layouts** to search the template's reusable slide layouts.

<div>
  <p>Open Deck Layouts, expand a layout, and inspect its ID and description</p>

  <div>
    <video>
      Your browser does not support the video tag.
    </video>
  </div>
</div>

<div>
  <p>Deck Layouts list with search, copy controls, Slide ID, and Slide Description</p>

  <div>
    <img alt="Deck Layouts panel showing searchable layout names, copy controls, an expanded Slide ID, and Slide Description" />
  </div>
</div>

For each important layout:

1. Confirm the **Slide ID** identifies the layout clearly.
2. Confirm the **Slide Description** matches the visible structure and intended use.
3. Use the copy control when the layout ID is needed elsewhere.

## Save the template

<div>
  <p>Template-level actions</p>

  <div>
    <img alt="Template actions with Copy ID, undo, redo, Delete Template, and Save" />
  </div>
</div>

Select **Save** after reviewing the edited slides and layout metadata. **Copy ID** copies the template identifier; undo and redo are available beside it.

<Warning>
  **Delete Template** removes the template. Use it only when deletion is intended.
</Warning>

<Card title="Template Creation" icon="wand-magic-sparkles" href="/user-guide/template-creation">
  Return to the separate workflow for creating a template from an existing PPTX.
</Card>


# Managing presentations
Source: https://docs.presenton.ai/user-guide/managing-presentations

Find, review, organize, and export presentations from the dashboard.

Use the dashboard to start new work, find saved presentations, open a deck in the editor, and export the reviewed result as a PDF or PPTX file.

## Watch the workflow

<video>
  <track label="English" />

  Your browser does not support the video tag.
</video>

## Manage presentations from the dashboard

The dashboard action row starts the main workflows: create a presentation, begin from a blank deck, import a PPTX for AI editing, or open the API Playground.

<div>
  <p>Dashboard actions for creating, importing, and using the API Playground</p>

  <div>
    <img alt="Presenton dashboard action row with Create new Presentation, Blank Presentation, Edit PPTX with AI, and API Playground" />
  </div>
</div>

The **Decks** section shows a preview, title, presentation type, and creation date for every saved presentation. Select a card to open it in the editor. Use the three-dot menu for actions that apply to that deck.

<div>
  <p>Saved presentations in the Decks section</p>

  <div>
    <img alt="Presenton Decks section with saved presentation cards, previews, titles, dates, and presentation types" />
  </div>
</div>

Cloud and open-source use the same presentation editor controls for naming, editing, and exporting. Use the dashboard actions visible in the current account or release to open or remove saved presentations. Cloud manages application storage. A self-hosted deployment owner must keep its persistent application storage available across upgrades and container replacement.

## Before exporting

* Review the story, slide order, and titles.
* Verify important numbers, names, and claims.
* Check text density, line wrapping, and content near slide edges.
* Inspect charts, tables, images, and custom fonts.
* Open the exported file once before sharing it.

<CardGroup>
  <Card title="Find and organize" icon="folder-open" href="/user-guide/managing-presentations/find-and-organize-presentations">
    Open, rename, and remove presentations.
  </Card>

  <Card title="Export presentations" icon="file-export" href="/user-guide/managing-presentations/export-presentations">
    Create and verify PPTX or PDF output.
  </Card>

  <Card title="Embed a presentation preview" icon="window-maximize" href="/user-guide/managing-presentations/embed-presentation-preview">
    Display a scoped, expiring presentation in your application with an iframe.
  </Card>
</CardGroup>


# Embed a presentation preview
Source: https://docs.presenton.ai/user-guide/managing-presentations/embed-presentation-preview

Create a scoped, expiring Presenton URL and display a presentation securely in your application with an iframe.

Use the Cloud API to create a temporary presentation URL, then load that URL in an iframe. This lets people view, edit, or export a specific presentation inside your application without exposing your Presenton API key or account session in browser code.

<Note>
  The integration endpoint is available in the Presenton Cloud API v3. Create the iframe URL on your server, not directly in the browser.
</Note>

## How the integration works

1. Your browser asks your application server for a presentation preview.
2. Your server verifies that the signed-in application user may access the presentation.
3. Your server calls `POST /api/v3/presentation/integrate` with its Presenton API key.
4. Presenton returns a scoped, expiring `frontend_url` containing a presentation token.
5. Your server returns that URL to the browser, which uses it as the iframe `src`.

The presentation token can access only the selected presentation and only the capabilities listed in `scopes`. It does not expose your main API key.

## Before you begin

You need:

* A Presenton Cloud API key stored in a server-side secret such as `PRESENTON_API_KEY`.
* The UUID of a presentation owned by the same Presenton account.
* A backend route in your application that authenticates your users before creating preview URLs.

If you generate the presentation through the API, use the returned `presentation_id`. You can also retrieve presentation IDs with [List presentations](/api-reference/v3-presentation/list-presentations).

## 1. Choose the iframe permissions

Every request must include `presentation:read`. Add only the capabilities your embedded experience needs.

| Scope                 | Embedded capability                                                   |
| --------------------- | --------------------------------------------------------------------- |
| `presentation:read`   | Load and view the presentation. Required for every integration token. |
| `presentation:edit`   | Use edit-capable actions, including chat edits and slide updates.     |
| `presentation:export` | Export the embedded presentation.                                     |

For a preview, use only:

```json theme={null}
{
  "scopes": ["presentation:read"]
}
```

For an embedded editor that can also export, request all three scopes:

```json theme={null}
{
  "scopes": [
    "presentation:read",
    "presentation:edit",
    "presentation:export"
  ]
}
```

<Warning>
  Anyone who obtains the generated URL can use its granted capabilities until it expires. Keep the scope set narrow and the lifetime short.
</Warning>

## 2. Create an integration URL

Call the integrate endpoint from your server with your Presenton API key:

```bash theme={null}
curl --request POST \
  --url https://api.presenton.ai/api/v3/presentation/integrate \
  --header "Authorization: Bearer $PRESENTON_API_KEY" \
  --header "Content-Type: application/json" \
  --data '{
    "presentation": "00000000-0000-0000-0000-000000000000",
    "scopes": ["presentation:read"]
  }'
```

### Request fields

| Field          | Required | Description                                                                                                           |
| -------------- | -------- | --------------------------------------------------------------------------------------------------------------------- |
| `presentation` | Yes      | UUID of the presentation to embed. The authenticated Presenton account must own it.                                   |
| `scopes`       | Yes      | One or more allowed capabilities. The list must include `presentation:read`.                                          |
| `expires_at`   | No       | Future ISO 8601 date and time. Defaults to 24 hours after creation and cannot be more than three days after creation. |

To set a shorter lifetime, calculate a future UTC timestamp when your server makes the request and send it as `expires_at`. The server example in the next section creates a one-hour link.

```json theme={null}
{
  "presentation": "00000000-0000-0000-0000-000000000000",
  "scopes": ["presentation:read"],
  "expires_at": "<future ISO 8601 timestamp>"
}
```

Presenton returns the token metadata and a ready-to-use URL:

```json theme={null}
{
  "token": "<presentation-token>",
  "frontend_url": "https://presenton.ai/presentation?id=00000000-0000-0000-0000-000000000000&type=smart&token=<presentation-token>",
  "user": "11111111-1111-1111-1111-111111111111",
  "presentation": "00000000-0000-0000-0000-000000000000",
  "scopes": ["presentation:read"],
  "version": "smart",
  "expires_at": "<ISO 8601 expiry>"
}
```

Use `frontend_url` exactly as returned. It already includes the presentation ID, presentation type, and scoped token; you do not need to construct the URL yourself.

## 3. Add a server endpoint

The following Express route creates a one-hour, read-only preview URL. Replace `requireUser` and `userCanViewPresentation` with your application's authentication and authorization checks.

```javascript theme={null}
import express from "express";

const app = express();
app.use(express.json());

app.post(
  "/api/presentations/:presentationId/preview",
  requireUser,
  async (request, response) => {
    const { presentationId } = request.params;

    if (!(await userCanViewPresentation(request.user, presentationId))) {
      return response.sendStatus(403);
    }

    const expiresAt = new Date(Date.now() + 60 * 60 * 1000).toISOString();
    const presentonResponse = await fetch(
      "https://api.presenton.ai/api/v3/presentation/integrate",
      {
        method: "POST",
        headers: {
          Authorization: `Bearer ${process.env.PRESENTON_API_KEY}`,
          "Content-Type": "application/json",
        },
        body: JSON.stringify({
          presentation: presentationId,
          scopes: ["presentation:read"],
          expires_at: expiresAt,
        }),
      },
    );

    if (!presentonResponse.ok) {
      return response.status(502).json({
        error: "Could not create the presentation preview",
      });
    }

    const integration = await presentonResponse.json();
    response.set("Cache-Control", "no-store");
    return response.json({
      url: integration.frontend_url,
      expiresAt: integration.expires_at,
    });
  },
);
```

Do not return your Presenton API key or place it in a public environment variable. The browser needs only the temporary `frontend_url`.

## 4. Render the iframe

Use the URL returned by your backend as the iframe source.

<Tabs>
  <Tab title="HTML and JavaScript">
    ```html theme={null}
    <iframe
      id="presenton-preview"
      class="presentation-frame"
      title="Presentation preview"
      allowfullscreen
    ></iframe>

    <script>
      async function loadPresentationPreview(presentationId) {
        const response = await fetch(
          `/api/presentations/${presentationId}/preview`,
          { method: "POST" },
        );

        if (!response.ok) {
          throw new Error("Could not load the presentation preview");
        }

        const { url } = await response.json();
        document.querySelector("#presenton-preview").src = url;
      }

      loadPresentationPreview("00000000-0000-0000-0000-000000000000");
    </script>
    ```
  </Tab>

  <Tab title="React">
    ```jsx theme={null}
    import { useEffect, useState } from "react";

    export function PresentationPreview({ presentationId }) {
      const [previewUrl, setPreviewUrl] = useState(null);
      const [error, setError] = useState(null);

      useEffect(() => {
        const controller = new AbortController();

        async function loadPreview() {
          try {
            const response = await fetch(
              `/api/presentations/${presentationId}/preview`,
              { method: "POST", signal: controller.signal },
            );

            if (!response.ok) throw new Error("Preview request failed");
            const { url } = await response.json();
            setPreviewUrl(url);
          } catch (previewError) {
            if (previewError.name !== "AbortError") setError(previewError);
          }
        }

        loadPreview();
        return () => controller.abort();
      }, [presentationId]);

      if (error) return <p>Could not load the presentation.</p>;
      if (!previewUrl) return <p>Loading presentation…</p>;

      return (
        <iframe
          src={previewUrl}
          title="Presentation preview"
          className="presentation-frame"
          allowFullScreen
        />
      );
    }
    ```
  </Tab>
</Tabs>

Add responsive sizing in your application stylesheet:

```css theme={null}
.presentation-frame {
  display: block;
  width: 100%;
  aspect-ratio: 16 / 9;
  min-height: 420px;
  border: 0;
  border-radius: 12px;
}

@media (max-width: 640px) {
  .presentation-frame {
    min-height: 70vh;
  }
}
```

Always provide a descriptive `title` for assistive technology. If the presentation is essential content, also provide a visible fallback link or explanation outside the iframe.

## Refresh expired previews

An expired token cannot be extended. Request a new integration URL from your backend and replace the iframe `src`.

A practical pattern is to keep the returned `expiresAt` value in memory and request a replacement shortly before it expires. Do not persist integration URLs in local storage, analytics events, logs, or shared caches.

## Security checklist

* Call the integrate endpoint only from trusted server-side code.
* Authorize the current application user before creating a URL for a presentation.
* Use `presentation:read` alone for preview-only experiences.
* Choose the shortest useful expiry; the maximum is three days.
* Send `Cache-Control: no-store` when your backend returns the URL.
* Treat `frontend_url` as a temporary credential because it contains the token.
* Create a new URL when permissions change instead of reusing an older URL.

## Troubleshooting

| Symptom                                            | Likely cause                                        | Resolution                                                                 |
| -------------------------------------------------- | --------------------------------------------------- | -------------------------------------------------------------------------- |
| `401 Unauthorized` from the integrate endpoint     | Missing or invalid API key                          | Verify the server-side `Authorization: Bearer ...` header.                 |
| `403` when creating the URL                        | The Presenton account does not own the presentation | Use a presentation created by the authenticated account.                   |
| `422 Validation Error`                             | Invalid UUID, scope, or request shape               | Include `presentation:read` and send a valid presentation UUID.            |
| `400` for `expires_at`                             | Expiry is in the past or more than three days away  | Send a future timestamp within the allowed window.                         |
| Preview loads but editing or export is unavailable | The token lacks the corresponding scope             | Create a new URL with `presentation:edit` or `presentation:export`.        |
| Preview stops loading later                        | The integration token expired                       | Request a fresh URL and replace the iframe source.                         |
| Browser refuses to frame the page                  | A self-hosted frontend restricts frame ancestors    | Configure the frontend to allow your application origin, then redeploy it. |

<Card title="Create a presentation integration token" icon="key" href="/api-reference/v3-presentation/create-a-presentation-integration-token">
  Review the complete request and response schema in the API reference.
</Card>


# Export presentations
Source: https://docs.presenton.ai/user-guide/managing-presentations/export-presentations

Download a reviewed presentation as PPTX or PDF and verify the result.

Use PPTX when recipients need an editable presentation file. Use PDF when fixed visual delivery, printing, or broad viewing compatibility matters more than editability.

Open the presentation from the dashboard. In the editor header, select **Export**, then choose **Export as PDF** or **Export as PPTX**. Export is unavailable while the presentation is still generating. When processing finishes, the file downloads automatically.

<div>
  <p>Review the presentation before export</p>

  <div>
    <img alt="Presenton editor with the current presentation and Export button in the header" />
  </div>
</div>

<div>
  <p>Choose PDF or PPTX from the Export menu</p>

  <div>
    <img alt="Presenton Export menu opened from the editor header with Export as PDF and Export as PPTX options" />
  </div>
</div>

## Final export check

<Steps>
  <Step title="Review the editor version">
    Check slide order, text overflow, image crops, chart labels, table cells, and object layers.
  </Step>

  <Step title="Export the required format">
    Choose **PPTX** for continued editing or **PDF** for a stable viewing copy. Export both when recipients need both workflows.
  </Step>

  <Step title="Open the downloaded file">
    Inspect every slide in the target application. Font substitution and text wrapping can differ from the browser preview.
  </Step>

  <Step title="Correct and re-export">
    Make changes in Presenton, export again, and distribute only the verified file.
  </Step>
</Steps>

## If an export looks different

| Problem                           | What to check                                                                                      |
| --------------------------------- | -------------------------------------------------------------------------------------------------- |
| Text wraps or overflows           | Font availability and substitution in the viewing application                                      |
| Images look incorrectly cropped   | Image crop and position in the editor                                                              |
| Charts or tables are hard to read | Labels, cell contents, colors, and slide scale                                                     |
| An older version downloads        | Confirm the latest edit is visible before exporting again                                          |
| Export fails                      | Wait for generation to finish, retry once, and verify the deployment's export service is available |

<Warning>
  Do not treat a successful download as visual validation. Always open the exported file before sharing it.
</Warning>

## Deliver the exported file

Share the verified PPTX or PDF through your organization's approved collaboration or storage service. Apply appropriate access controls and re-export after the final change instead of distributing an older download.


# Find and organize presentations
Source: https://docs.presenton.ai/user-guide/managing-presentations/find-and-organize-presentations

Open, rename, and remove presentations from the dashboard.

The dashboard lists saved presentations under **Decks**. Each card shows the presentation type, first-slide preview, title, creation date, and a three-dot actions menu.

Select a card to open the presentation editor. To rename the presentation, select its title in the editor header, enter the new title, and save the change. The title is also used to create a safe filename during export.

<div>
  <p>Saved presentation cards in the Decks section</p>

  <div>
    <img alt="Presenton Decks section with saved presentation cards, previews, titles, dates, and presentation types" />
  </div>
</div>

## Presentation card actions

Select the three-dot menu on a presentation card to open its available actions.

<div>
  <p>Presentation card with preview, title, date, and actions menu</p>

  <div>
    <img alt="Presenton presentation card showing the slide preview, Standard label, title, date, and three-dot menu" />
  </div>
</div>

* **Delete** removes the selected presentation after confirmation.

<Warning>
  Check the card title and preview before confirming deletion. Export a copy first if the presentation must be retained outside Presenton.
</Warning>

## Open and review a presentation

Select a presentation card to open its slides in the editor. Use the thumbnail rail to review the deck, then select **Export** when it is ready to download.

<div>
  <p>Presentation opened from the dashboard</p>

  <div>
    <img alt="Presenton editor with slide thumbnails, the active slide, editing tools, and Export in the header" />
  </div>
</div>

## Naming pattern

Use a title that distinguishes purpose and version, for example `Q3 Product Review - Leadership - Final`. Keep draft status in the title only while it is useful, and rename the final deck before export.

## If a presentation is hard to find

* Confirm you are using the same Presenton deployment and account where it was created.
* Look for the title and creation date shown on the card.
* Open likely matches and check the first-slide preview and slide contents.
* Rename important presentations before exporting them.


# Onboarding flow
Source: https://docs.presenton.ai/user-guide/onboarding

Set up Presenton Cloud or open-source Presenton.

## Complete onboarding

Choose **Cloud** to register and open the managed dashboard. Choose **Open-source** to configure your local or self-hosted installation.

<Tabs>
  <Tab title="Cloud">
    1. Register for a Presenton Cloud account.
    2. [Log in](https://presenton.ai/auth/login).
    3. Choose a mode from the dashboard.

    <div>
      <p>Register or sign in to Presenton Cloud</p>

      <div>
        <img alt="Presenton Cloud registration and login page" />
      </div>
    </div>

    <div>
      <p>Your three Cloud workflows</p>

      <div>
        <img alt="Cloud dashboard showing Create new Presentation, Edit PPTX with AI, and API Playground" />
      </div>
    </div>

    <AccordionGroup>
      <Accordion title="Create new Presentation">
        Create a presentation from a prompt or reference files.

        [Start with Create new Presentation](/user-guide/create-new-presentation)
      </Accordion>

      <Accordion title="Edit PPTX with AI">
        Import an existing PPTX and edit it with AI.

        [Start with Edit PPTX with AI](/user-guide/cloud/edit-pptx-with-ai)
      </Accordion>

      <Accordion title="API Playground">
        Test presentation generation and get API request code.

        [Start with API Playground](/user-guide/cloud/api-playground)
      </Accordion>
    </AccordionGroup>

    <Card title="Create new Presentation" icon="arrow-right" href="/user-guide/create-new-presentation">
      Generate a deck from a prompt or reference files.
    </Card>
  </Tab>

  <Tab title="Open-source">
    Open-source onboarding configures local access and the providers used by your local or self-hosted Presenton installation. You can optionally connect a Presenton account as the generation provider without using it as the local login.

    <Steps>
      <Step title="Registration">
        Create the first administrator account when the setup screen asks for it. Open-source Presenton does not require a Presenton Cloud account.

        <div>
          <p>Create the administrator account</p>

          <div>
            <img alt="Close-up of the open-source administrator registration form" />
          </div>
        </div>
      </Step>

      <Step title="Login">
        Log in with the administrator account when authentication is enabled.

        <div>
          <p>Sign in to your Presenton installation</p>

          <div>
            <img alt="Open-source Presenton administrator login" />
          </div>
        </div>
      </Step>

      <Step title="Select text provider">
        Choose where presentation content is generated: Presenton Cloud, ChatGPT, a local model, or an API provider.

        <div>
          <p>Choose ChatGPT, Local, or an API provider</p>

          <div>
            <img alt="Close-up of the open-source text provider choices: ChatGPT, Local, and AI Providers" />
          </div>
        </div>

        <AccordionGroup>
          <Accordion title="Presenton Cloud">
            Select **Presenton**, copy the displayed device code, and approve it on the hosted Presenton page. Only the local administrator can manage this installation-wide connection. It is separate from the local account used to sign in to this installation.
          </Accordion>

          <Accordion title="ChatGPT">
            Sign in with ChatGPT, then select a supported model.

            <div>
              <p>Sign in with ChatGPT, then select a model</p>

              <div>
                <img alt="Close-up of ChatGPT selected with a model dropdown in open-source onboarding" />
              </div>
            </div>
          </Accordion>

          <Accordion title="Local">
            Select a local provider such as Ollama or LM Studio, enter the local URL, then check available models.

            <div>
              <p>Connect Ollama or LM Studio</p>

              <div>
                <img alt="Close-up of local text provider setup with Ollama and LM Studio" />
              </div>
            </div>
          </Accordion>

          <Accordion title="API provider">
            Select an API provider, enter its API key or endpoint, then validate and load models.

            <div>
              <p>Connect an API provider and load its models</p>

              <div>
                <img alt="Close-up of API text provider setup with an OpenAI API key field" />
              </div>
            </div>
          </Accordion>
        </AccordionGroup>
      </Step>

      <Step title="Select image provider">
        Enable image generation if you want Presenton to create visuals, then choose the provider.

        <div>
          <p>Enable images and select a provider</p>

          <div>
            <img alt="Close-up of open-source image provider choices including Pexels, Pixabay, DALL-E, Gemini, ComfyUI, Open WebUI, and Custom" />
          </div>
        </div>
      </Step>

      <Step title="Select web search provider">
        Enable web search when generated presentations should include current web context, then choose the search provider.

        <div>
          <p>Enable web search and select a provider</p>

          <div>
            <img alt="Close-up of open-source web search provider choices including Default, SearXNG, Tavily, Exa, and Brave" />
          </div>
        </div>
      </Step>

      <Step title="Generate New Presentation dashboard">
        Start your first deck from the Generate page. Enter a prompt, choose slide count and language, attach files if needed, then select **Get Started**.

        <div>
          <p>Start from the Generate page</p>

          <div>
            <img alt="Close-up of the open-source Generate page with prompt, attachments, controls, and Get Started" />
          </div>
        </div>
      </Step>
    </Steps>

    [Text provider settings](/self-hosted/configuration/text-providers) · [Image and search settings](/self-hosted/configuration/images-and-search) · [Create new Presentation](/user-guide/create-new-presentation#open-source)
  </Tab>
</Tabs>


# Start with Editing
Source: https://docs.presenton.ai/user-guide/presentation-editor

Open a presentation, choose the right editing tool, and export the result.

Use the editor after AI generation or when reopening a saved presentation. The workspace has three parts:

* **Slide rail:** select the slide to edit.
* **Canvas:** review and edit the active slide.
* **Editor rail:** add blocks, text, charts, tables, images, elements, or open AI.

## Watch the editing workflow

This narrated walkthrough shows how to select a slide, edit text and objects on the canvas, add content from the editor rail, use AI for a focused change, and review the result.

<video>
  Your browser does not support the video tag.
</video>

## Edit a presentation

<Steps>
  <Step title="Open the slide">
    Select a thumbnail from the slide rail.
  </Step>

  <Step title="Choose an editing path">
    Use the canvas for direct changes, AI for a focused request, or the slide rail to add a slide.
  </Step>

  <Step title="Make one change">
    Edit the selected content, then check the result before moving to another element.
  </Step>

  <Step title="Review and export">
    Confirm the slide sequence, content, and layout. Select **Export**, then choose **PDF** or **PPTX**.
  </Step>
</Steps>

## Choose the right tool

<CardGroup>
  <Card title="Canvas editor" icon="object-group" href="/user-guide/editing-and-refining/canvas-editor">
    Add or directly edit blocks, text, images, shapes, tables, and charts.
  </Card>

  <Card title="AI assistant" icon="sparkles" href="/user-guide/editing-and-refining/ai-assistant">
    Describe one focused change for the active slide.
  </Card>

  <Card title="Slide Editing" icon="images" href="/user-guide/editing-and-refining/slide-editing">
    Select a slide or add a new one from the slide rail.
  </Card>

  <Card title="Template Editing" icon="layer-group" href="/user-guide/editing-and-refining/template-editing">
    Refine schema behavior, reconstruction, and layout metadata in a saved template.
  </Card>
</CardGroup>

## Export the result

<div>
  <p>Export options verified in the editor</p>

  <div>
    <img alt="Export menu with PDF and PPTX options" />
  </div>
</div>

Select **Export**, then choose **PDF** or **PPTX**. Open the downloaded file and check text wrapping, image crops, chart labels, table values, and object positions.


# Start With Presenton
Source: https://docs.presenton.ai/user-guide/start-with-presenton

Learn what Presenton is and choose Cloud or open-source setup.

## About Presenton

Presenton helps you create editable presentations from a prompt, reference files, or one of your existing presentations.

## See the complete workflow

<video>
  Your browser does not support the video tag.
</video>

<CardGroup>
  <Card title="Generate from your content" icon="wand-magic-sparkles" href="/user-guide/create-new-presentation">
    Create a presentation from a topic, brief, document, or other supported file.
  </Card>

  <Card title="Turn your own PPTX into a template" icon="file-powerpoint" href="/user-guide/branding-and-design/templates">
    Keep its layouts and branding, generate new presentations with the template, and edit the content with AI.
  </Card>

  <Card title="Edit with AI" icon="pen-to-square" href="/user-guide/presentation-editor">
    Update slide content and design directly or ask the AI Assistant to make changes.
  </Card>

  <Card title="Export a file" icon="file-export" href="/user-guide/managing-presentations/export-presentations">
    Export the finished presentation as PPTX or PDF.
  </Card>
</CardGroup>

## Setup

<Tabs>
  <Tab title="Cloud">
    Use the managed version of Presenton. No installation or AI provider configuration is required.

    1. Open [Presenton Cloud](https://presenton.ai/auth/login).
    2. Register or log in.
    3. Continue to the dashboard.

    <div>
      <p>Register or sign in to Presenton Cloud</p>

      <div>
        <img alt="Presenton Cloud registration and login page" />
      </div>
    </div>
  </Tab>

  <Tab title="Open-source">
    Choose one of two ways to run open-source Presenton:

    <div>
      <Card title="Download the desktop app" icon="download" href="https://presenton.ai/download">
        Install Presenton on Windows, macOS, or Linux. Choose this for local use without managing Docker.
      </Card>

      <div aria-label="or">OR</div>

      <Card title="Host with Docker" icon="docker" href="/hosting/overview">
        Run Presenton in Docker on your computer or server. Choose this for a hosted or shared deployment.
      </Card>
    </div>

    Need detailed instructions? Read [Install the desktop app](/self-hosted/tutorials/install-desktop-app) or [Hosting Presenton](/hosting/overview).
  </Tab>
</Tabs>

<Card title="Next: Onboarding flow" icon="arrow-right" href="/user-guide/onboarding" />


# Template creation
Source: https://docs.presenton.ai/user-guide/template-creation

Turn a PowerPoint design into a reusable presentation template.

Create a template from a filled PowerPoint presentation when you want generated decks to follow an existing design. Each source slide can become a reusable layout.

<Tip>
  Use a presentation with representative content instead of an empty slide master. Distinct slide designs help Template Studio identify useful layouts.
</Tip>

## Start with a built-in template

Before creating a custom template, open **Templates** and select the **Built-in** tab. Built-in templates are ready to use and can save time when one already matches the structure and visual style you need.

Each template card shows a slide preview, the number of available layouts, a template name, and a short description. Compare these details to choose a template that fits the intended presentation.

<div>
  <p>Browse the built-in template library</p>

  <div>
    <img alt="Built-in tab of the Templates library showing Dynamic, Momentum, Executive, General, Swift, Standard, and Modern templates with layout counts and previews" />
  </div>
</div>

<Note>
  Create a custom template only when the built-in library does not provide the layouts or brand treatment you need.
</Note>

## Complete workflow

This short walkthrough shows how to open Template Studio, upload a filled PowerPoint presentation, review the detected fonts and source slides, and turn its layouts into a reusable template.

<video>
  Your browser does not support the video tag.
</video>

## Create the template step by step

<Steps>
  <Step title="Open the template library">
    Open **Templates** and select **Build Template** or **New Template**.

    <div>
      <p>Open the custom template library</p>

      <div>
        <img alt="Close-up of the Templates page with the Build Template card, a custom template, and New Template button" />
      </div>
    </div>
  </Step>

  <Step title="Upload the PowerPoint file">
    Select **Upload PPTX File**, choose the presentation you want to reuse, and wait until its status changes to **Ready**. Select **Get Started** to continue.

    <div>
      <p>PPTX file ready for Template Studio</p>

      <div>
        <img alt="Close-up of Template Studio showing an uploaded PPTX file ready to process" />
      </div>
    </div>
  </Step>

  <Step title="Review the detected fonts">
    Template Studio analyzes the fonts used by the presentation. Upload any missing font files shown in the font list so text keeps its intended typography, spacing, and wrapping.

    <div>
      <p>Review detected fonts and upload missing files</p>

      <div>
        <img alt="Close-up of Template Studio font analysis with detected fonts and a missing font upload control" />
      </div>
    </div>
  </Step>

  <Step title="Preview the source slides">
    Inspect the slide thumbnails and the large preview. Confirm that the presentation contains the layouts you want to reuse, then select **Create Template**.

    <div>
      <p>Preview source slides before creating layouts</p>

      <div>
        <img alt="Close-up of Template Studio with a source slide, thumbnails, and Create Template action" />
      </div>
    </div>
  </Step>

  <Step title="Name the template">
    Enter a clear template name. Add a description that explains when the design should be used, then select **Create**.

    <div>
      <p>Enter the template name and description</p>

      <div>
        <img alt="Close-up of the Create Template dialog with template name and description fields" />
      </div>
    </div>
  </Step>

  <Step title="Monitor template generation">
    The template appears in the **Custom** library while its layouts are generated. Wait for generation to finish before using it in a presentation.

    <div>
      <p>Template generation progress in the Custom library</p>

      <div>
        <img alt="Close-up of the Custom template library showing layout generation progress" />
      </div>
    </div>
  </Step>
</Steps>

## Verify the result

After generation finishes, open the template and review its layouts. Create a short test presentation and check that text remains readable, visual elements are positioned correctly, and the exported PPTX matches the intended design.

<Tip>
  A smaller collection of reliable, distinct layouts is more useful than many near-duplicate slides.
</Tip>

<CardGroup>
  <Card title="Refine the template" icon="layer-group" href="/user-guide/editing-and-refining/template-editing">
    Edit text behavior, schema limits, reconstructed slides, and layout metadata after the template is created.
  </Card>

  <Card title="Create a presentation" icon="wand-magic-sparkles" href="/user-guide/create-new-presentation">
    Test the finished template in a short Standard presentation.
  </Card>
</CardGroup>


# Charts and visual content
Source: https://docs.presenton.ai/user-guide/working-with-content/charts-and-visual-content

Create and edit charts, tables, diagrams, icons, shapes, and visual layouts.

Use the Standard presentation editor to add structured data, visual explanations, and reusable layouts to a slide. Open the relevant tool in the editor rail, choose an element, and refine it on the canvas.

## Edit charts and tables directly

Use a chart when the audience needs to see a pattern or comparison. Use a table when exact values matter. Add and edit both from the Canvas editor.

<Card title="Add and edit tables and charts" icon="chart-column" href="/user-guide/editing-and-refining/canvas/table-editing">
  Watch the complete Canvas workflow for adding a chart and table, then editing their content directly.
</Card>

<Tabs>
  <Tab title="Charts">
    Open **Charts**, then choose a chart or infographic that matches the relationship in the data.

    <div>
      <p>Chart and infographic types</p>

      <div>
        <img alt="Charts panel showing bar, horizontal bar, stacked bar, line, pie, area, donut, scatter, radar, polar area, progress bar, and gauge chart options" />
      </div>
    </div>

    After adding a chart, select it on the canvas to edit its data and presentation. Depending on the chart type, you can configure the title, values, category labels, legend, axes, grid, and series colors.
  </Tab>

  <Tab title="Tables">
    Open **Tables** and select **Simple Table**.

    <div>
      <p>Simple Table in the editor rail</p>

      <div>
        <img alt="Tables panel showing the Simple Table option" />
      </div>
    </div>

    Select a table cell to edit its content. Use the table actions to add or remove rows and columns, or move a column left or right. Verify every label and value against the source data.
  </Tab>
</Tabs>

### Chart controls

The Standard editor groups its chart choices by purpose:

| Chart family                        | Types                                                  |
| ----------------------------------- | ------------------------------------------------------ |
| Bars and columns                    | Bar, Horizontal Bar, Stacked Bar, Horizontal Stack Bar |
| Lines and areas                     | Line, Area                                             |
| Proportions                         | Pie, Donut, Polar Area                                 |
| Relationships and radial comparison | Scatter, Bubble, Radar                                 |

Use bar charts for category comparison, line or area charts for change over time, pie-like charts for a small number of parts in a whole, and scatter or bubble charts for relationships between measures.

## Build diagrams with icons and shapes

Combine icons, labels, shapes, arrows, and lines when the audience needs to understand a process, hierarchy, or relationship. Keep the reading direction obvious and use one visual meaning for each shape or color.

### Edit and replace icons

Select an icon on the slide to update its color or replace its symbol. Use **Change Icon** to search for a concept, compare matching symbols, choose an icon weight, and apply the replacement.

<Card title="Edit images and icons" icon="photo-film" href="/user-guide/editing-and-refining/canvas/image-editing#edit-an-icon">
  Follow the Canvas guide to recolor an icon or replace it with a better symbol.
</Card>

### Add shapes and connectors

Open **Elements** to insert a rectangle, circle, ellipse, triangle, diamond, pentagon, hexagon, arrow, or line. Select the element on the canvas to move, resize, rotate, or restyle it.

<Card title="Edit shapes and lines" icon="shapes" href="/user-guide/editing-and-refining/canvas/shape-editing">
  Watch the focused Canvas guide for positioning and styling shapes, lines, and connectors.
</Card>

## Add a reusable visual layout

Open **Blocks** when you need a complete slide section rather than one object. Search the block library, review the available layout variants, and select the layout that matches the content you need to present.

<Card title="Blocks and layout" icon="square" href="/user-guide/editing-and-refining/canvas/block-editing">
  Browse reusable block families, compare layout variants, and add a complete visual section to the active slide.
</Card>

## Choose the right visual form

| Use                    | When the audience needs                            |
| ---------------------- | -------------------------------------------------- |
| **Chart**              | A pattern, trend, distribution, or comparison      |
| **Table**              | Exact values or a structured comparison            |
| **Diagram**            | A process, hierarchy, sequence, or relationship    |
| **Icon**               | A compact label or recognizable concept            |
| **Shape or connector** | Emphasis, grouping, direction, or a custom diagram |
| **Block layout**       | A reusable arrangement of several related elements |

## Review before delivery

* Recalculate source values and derived percentages.
* Confirm that axes do not distort the comparison.
* Include units, dates, category labels, and data source context.
* Check that colors remain distinguishable and text remains legible.
* Confirm that table values, chart categories, series, and source labels still match the source after editing.
* Open the exported PPTX or PDF and inspect labels for clipping.


# Documents
Source: https://docs.presenton.ai/user-guide/working-with-content/documents

Turn reports, briefs, PDFs, presentations, spreadsheets, text, and images into a grounded deck.

Use a document when the presentation must follow existing facts or a known narrative. The most reliable workflow combines a focused source with a short instruction explaining what the audience needs from it.

## Supported source files

The visible source-file list differs between the live Cloud and open-source screens. Always follow the list shown by the product you are using.

<Tabs>
  <Tab title="Cloud">
    The current Cloud Generate screen advertises these extensions:

    `.pdf`, `.txt`, `.md`, `.pptx`, `.ppt`, `.docx`, `.doc`, `.csv`, `.xlsx`, `.xls`, `.html`, `.htm`, `.adoc`, and `.asciidoc`.

    <img alt="Generate page with the prompt, presentation controls, attachment area, and supported source-file formats" />

    <div>Attach documents and review supported source formats</div>
  </Tab>

  <Tab title="Open-source">
    The current open-source Generate screen describes the upload area as accepting **Office docs, spreadsheets, images, PDF/TXT**. The exact extensions and processing behavior are controlled by the installed release and deployment configuration.

    The current local upload component accepts up to eight supporting files. Remove unrelated or duplicate files before uploading.

    <img alt="Generate page with the prompt, provider summary, attachment area, and source categories" />

    <div>Attach office documents, spreadsheets, images, PDFs, or text</div>
  </Tab>
</Tabs>

## Prepare the source

* Use one authoritative file for the first attempt.
* Remove unrelated appendices, duplicate versions, and hidden spreadsheet sheets.
* Note the names, dates, figures, and conclusions that must remain exact.
* Prefer selectable text. Scanned PDFs and images depend on OCR quality.
* Use clear headings and labels so extracted sections retain their meaning.

## Generate from a document

Cloud and open-source use the same document-to-presentation sequence, with product-specific source lists and provider behavior.

<Steps>
  <Step title="Open Generate">
    Start a new presentation and open the Generate page.
  </Step>

  <Step title="Attach the source">
    Select **Attachments (optional)** or drop one or more files accepted by the active product into the upload area. Wait until each filename appears, then choose an explicit output language. You can clear all attachments or remove an individual file before continuing.

    <img alt="Generate page with an attached source document" />

    <div>A source document ready to process</div>
  </Step>

  <Step title="Explain how to use it">
    Add a prompt that names the audience, desired outcome, priority sections, and facts that must be preserved.
  </Step>

  <Step title="Process the source">
    Set the remaining controls and select **Get Started**. Presenton uploads and decomposes the files, then requests outline generation. Large or scanned sources can take longer.
  </Step>

  <Step title="Review the outline against the source">
    Correct omissions, unsupported claims, and sequencing before choosing the presentation design.

    <img alt="Presentation outline generated from an uploaded document" />

    <div>Review the generated outline before choosing a design</div>

    <img alt="Outline with editable content, template selection, and presentation controls" />

    <div>Review the outline and choose a template</div>
  </Step>

  <Step title="Generate and verify">
    Compare the finished slides with the source, then export and inspect the result.
  </Step>
</Steps>

<Note>
  Open-source document parsing, OCR, supported file behavior, and limits depend on the services configured by the deployment administrator. When files are attached, the current browser flow requires an explicit language instead of **Auto**. Cloud account limits can also change independently of the visible file-extension list.
</Note>

<Warning>
  Verify every important number, date, name, chart, table, and claim against the original file. Document grounding reduces guesswork but does not replace review.
</Warning>

<CardGroup>
  <Card title="Generation workflow" icon="wand-magic-sparkles" href="/user-guide/create-new-presentation">
    Follow the complete prompt, attachment, outline, and generation workflow.
  </Card>

  <Card title="Edit the generated slides" icon="pen-to-square" href="/user-guide/presentation-editor">
    Choose direct Canvas editing or use the AI assistant after generation.
  </Card>
</CardGroup>


# Images and media
Source: https://docs.presenton.ai/user-guide/working-with-content/images-and-media

Use uploaded, stock, generated, and editable visuals in presentation slides.

Choose visuals for evidence or explanation. Product screenshots, diagrams, charts, and specific photographs usually communicate more than generic decorative images. Add the visual during generation when it belongs to the story, or replace it later from the editor.

## Add an image layout

Open **Images** in the editor rail, then choose **Image**, **Image + Text**, or **Image Grid**. Select the option that matches the amount of visual content and supporting text the slide needs.

<Card title="Add and edit images" icon="photo-film" href="/user-guide/editing-and-refining/canvas/image-editing#add-an-image-layout">
  Watch how to add Image, Image + Text, and Image Grid layouts from the editor rail.
</Card>

## Replace and adjust an image

Enable **Select Edit**, then select the image. Select it again to open **Update Image**. The panel has three tabs:

* **Stock search** or **AI Generate**: search Pexels/Pixabay when a stock provider is configured, or describe an image for the configured image-generation provider. Generated-image history can be available when stock search is not active.
* **Upload**: upload an image, choose it from the uploaded-image library, or delete an uploaded asset. The current editor upload limit is 5 MB per image.
* **Edit**: replace the image and choose **Fill**, **Contain**, or **Stretch**. Use **Focus point** to control which part remains visible when the image is fitted or cropped.

The canvas controls also support direct image positioning and the element-specific crop, zoom, flip, opacity, rounded-corner, and supported-icon color controls.

<Card title="Replace and adjust an image" icon="image" href="/user-guide/editing-and-refining/canvas/image-editing#edit-an-image">
  Follow the canonical Canvas workflow for replacing, cropping, resizing, and positioning an image.
</Card>

## Recolor or replace an icon

Select an icon to change its color. Choose **Change Icon** when the symbol does not match the intended concept, search for a replacement, compare the available weights, and apply the new icon.

<Card title="Edit an icon" icon="icons" href="/user-guide/editing-and-refining/canvas/image-editing#edit-an-icon">
  Open the icon walkthrough for recoloring a symbol or choosing a replacement.
</Card>

## Provider availability

| Product     | How image sources are provided                                                                                 |
| ----------- | -------------------------------------------------------------------------------------------------------------- |
| Cloud       | Image generation and search are provided by the Cloud configuration shown in the product                       |
| Open-source | The deployment owner configures the image provider, credentials, URLs, and whether image generation is enabled |

The current self-hosted provider configuration includes stock providers such as Pexels and Pixabay, generated-image providers such as DALL-E 3, GPT Image 1.5, Gemini Flash, and NanoBanana Pro, and configurable options such as ComfyUI, Open WebUI, or a custom OpenAI-compatible image endpoint. Only use providers that are enabled in your product or deployment.

<Card title="Configure image providers" icon="images" href="/self-hosted/configuration/images-and-search">
  Review provider, credential, endpoint, and image-generation settings for a self-hosted deployment.
</Card>

## Choose the right visual

| Visual              | Best use                                          |
| ------------------- | ------------------------------------------------- |
| Uploaded screenshot | Product state, evidence, or a process step        |
| Stock photograph    | A real place, person, object, or familiar concept |
| Generated image     | A custom scene, illustration, or visual metaphor  |
| Icon                | A compact label or simple concept                 |
| Chart               | A pattern, comparison, distribution, or trend     |
| Table               | Exact values or a structured comparison           |

Always check relevance, cropping, legibility, source rights, and exported fidelity.


# Upload source files (self-hosted)
Source: https://docs.presenton.ai/api-reference/files/upload-source-files

/openapi/self-hosted.json post /api/v1/ppt/files/upload
Upload supported source files and return identifiers that can be used in self-hosted generation requests.

[Read the files and content guide](/user-guide/api-and-automation/files-and-content).



# Delete image (self-hosted)
Source: https://docs.presenton.ai/api-reference/images/delete-an-uploaded-image

/openapi/self-hosted.json delete /api/v1/ppt/images/{id}
Delete one uploaded image from this Presenton instance.

[Read the files and content guide](/user-guide/api-and-automation/files-and-content).



# Uploaded images (self-hosted)
Source: https://docs.presenton.ai/api-reference/images/list-uploaded-images

/openapi/self-hosted.json get /api/v1/ppt/images/uploaded
List images stored by this Presenton instance.

[Read the files and content guide](/user-guide/api-and-automation/files-and-content).



# Upload image (self-hosted)
Source: https://docs.presenton.ai/api-reference/images/upload-an-image

/openapi/self-hosted.json post /api/v1/ppt/images/upload
Upload an image to this Presenton instance.

[Read the files and content guide](/user-guide/api-and-automation/files-and-content).



# Subscribe webhook (self-hosted)
Source: https://docs.presenton.ai/api-reference/webhook/subscribe-a-webhook

/openapi/self-hosted.json post /api/v1/webhook/subscribe
Subscribe an endpoint to supported events from this Presenton instance.

[Read the async and webhooks guide](/user-guide/api-and-automation/async-and-webhooks).



# Unsubscribe webhook (self-hosted)
Source: https://docs.presenton.ai/api-reference/webhook/unsubscribe-a-webhook

/openapi/self-hosted.json delete /api/v1/webhook/unsubscribe
Remove one webhook subscription from this Presenton instance.

[Read the async and webhooks guide](/user-guide/api-and-automation/async-and-webhooks).



# Presenton Documentation
Source: https://docs.presenton.ai/index

Create, edit, automate, and operate Presenton across Cloud and self-hosted deployments.

<div>
  <section>
    <div>Build with <span>Presenton</span></div>
    <p>Editable presentation workflows for prompts, files, templates, and APIs.</p>
  </section>

  <section aria-label="Presenton documentation paths">
    <div>
      <a href="/general/overview" aria-label="Understand Presenton" />

      <div>
        <img alt="" />

        <img alt="" />
      </div>

      <div>
        <p>Understand Presenton</p>
        <p>Start with the product overview, workflow, core concepts, deployment modes, and feature availability.</p>
      </div>
    </div>

    <div>
      <a href="/user-guide/create-new-presentation" aria-label="Create and edit decks" />

      <div>
        <img alt="" />

        <img alt="" />
      </div>

      <div>
        <p>Create and edit decks</p>
        <p>Generate a first draft, refine slides, work with content blocks, and export to PPTX or PDF.</p>
      </div>
    </div>

    <div>
      <a href="/user-guide/branding-and-design/templates" aria-label="Use reusable templates" />

      <div>
        <img alt="" />

        <img alt="" />
      </div>

      <div>
        <p>Use reusable templates</p>
        <p>Bring existing presentation designs into repeatable templates for consistent, editable output.</p>
      </div>
    </div>

    <div>
      <a href="/hosting/overview" aria-label="Run Presenton yourself" />

      <div>
        <img alt="" />

        <img alt="" />
      </div>

      <div>
        <p>Run Presenton yourself</p>
        <p>Install Presenton with Docker, configure providers, and explore support for custom enterprise requirements.</p>
      </div>
    </div>

    <div>
      <a href="/user-guide/api-and-automation/overview" aria-label="Build with the API" />

      <div>
        <img alt="" />

        <img alt="" />
      </div>

      <div>
        <p>Build with the API</p>
        <p>Generate, track, edit, and export presentations from your product, automation, or internal workflow.</p>
      </div>
    </div>

    <div>
      <a href="/troubleshooting" aria-label="Troubleshoot and compare versions" />

      <div>
        <img alt="" />

        <img alt="" />
      </div>

      <div>
        <p>Troubleshoot and compare versions</p>
        <p>Diagnose generation, editing, export, hosting, and integration issues, or open a frozen documentation snapshot.</p>
      </div>
    </div>
  </section>
</div>


# Account and access problems
Source: https://docs.presenton.ai/troubleshooting/account-and-access

Fix sign-in problems and find presentations that appear to be missing.

## I cannot sign in

1. Confirm that you are opening the correct Presenton Cloud or self-hosted address.
2. Enter the username or email for that account again instead of relying on an old saved browser value.
3. Check Caps Lock and remove accidental spaces before or after the password.
4. Try a private browser window to rule out an expired session or browser extension problem.
5. If you still cannot sign in, contact your workspace or Presenton administrator to verify the account and reset access.

<Note>
  A Presenton API key beginning with `sk-presenton-` cannot be used to sign in to the browser. It authenticates REST API and MCP requests only.
</Note>

## My presentations or templates are missing

* Confirm that you signed in with the same account and opened the same Presenton deployment you used before.
* Check whether you are viewing Presenton Cloud, a local installation, or a different self-hosted server. Their workspaces are separate.
* Ask your administrator whether your account was changed, removed, or recreated. Content belongs to the account that created it.
* If only one presentation is missing, check whether it was duplicated, renamed, or deleted from another browser session.

## I was signed out while working

Sign in again, reopen the presentation, and check the latest saved state before repeating any edits. If sign-outs continue across browsers, record the time they happen and ask your administrator to check session or authentication changes.

## If you administer self-hosted Presenton

* Confirm that the user is opening the correct server and that the account still exists under **Admin → Users**.
* Use the documented reset or recovery flow instead of editing authentication data in `/app_data` manually.
* Credential override and authentication recovery can invalidate existing browser sessions and API keys.
* If all users appear new or all content is missing, confirm the container mounts the original persistent directory at `/app_data`.

See [Authentication](/self-hosted/configuration/authentication) for user management, credential rotation, and administrator recovery.


# API and integration problems
Source: https://docs.presenton.ai/troubleshooting/api-and-integrations

Fix authentication, asynchronous tasks, webhooks, and MCP connections.

<Info>
  This page is for developers and administrators. If you create and edit presentations in the browser, start from the main [Troubleshooting guide](/troubleshooting).
</Info>

## Cloud integrations

* Confirm the request uses the documented Cloud v3 base URL, method, path, content type, and a valid bearer token.
* Do not send self-hosted v1 payloads or authentication keys to Cloud endpoints.
* Record the sanitized request shape, HTTP status, response body, request identifier, and time of the failure.
* Treat asynchronous intermediate states as non-final, preserve the task identifier, and poll until it reaches a documented final state.
* Make webhook processing idempotent, deduplicate repeated deliveries, and return a successful response promptly after accepting an event.

## Self-hosted integrations

* Confirm the request uses the v1 endpoints exposed by the installed release rather than Cloud v3 paths.
* Confirm the request sends an active `sk-presenton-...` API key as a bearer token without logging or exposing it.
* Generate a replacement key after administrator credential recovery, rotation, or suspected exposure.
* Confirm the MCP client can reach the Presenton host from its network environment; MCP is unavailable in the desktop app.
* Check application logs for route, authentication, validation, provider, rendering, and background-task failures.
* Retry with a minimal payload, then add files, templates, webhooks, and optional fields one at a time.


# Files, content, and image problems
Source: https://docs.presenton.ai/troubleshooting/content-and-media

Fix uploads, missing source content, unreadable files, and incorrect or missing images.

## A file will not upload

1. Open the file on your computer to confirm it is not damaged.
2. Remove password protection or encryption before uploading it.
3. Save older Office files in a current format, such as `.docx`, `.pptx`, or `.xlsx`.
4. Rename the file with a short, simple filename and try again.
5. If the file is large, create a smaller copy containing only the pages or sheets you need.

Try a small file of the same type. If the small file works, the original file's size, protection, or contents are likely the cause.

## Important source content is missing

* Use a text-based PDF when possible. Scanned pages may need clearer scans or OCR before upload.
* Give documents clear headings and give spreadsheet columns consistent labels.
* Check that tables, chart labels, and numerical values are readable at normal zoom.
* Mention the facts or sections that matter most in your prompt.
* Compare the generated outline with the source before creating slides, then add any missing topics to the outline.

## Images are missing, irrelevant, or low quality

* Describe the subject and visual style more specifically in the prompt.
* Replace an unsuitable image in the editor instead of regenerating the entire presentation.
* Confirm that an uploaded image opens normally and has enough resolution for the intended slide size.
* If every generated presentation lacks images, ask your Presenton administrator to check the configured image or search provider.

## If you manage a self-hosted instance

* Confirm the upload and persistent-data directories are writable and have sufficient free space.
* Check document-processing logs for parser, OCR, unsupported-format, file-size, memory, or timeout errors.
* Verify image and search provider credentials and connectivity independently from the text provider.
* For services running on the host, use a hostname and port reachable from the container rather than container `localhost`.

Never share a confidential source document just to reproduce a problem. Create a small sanitized file with the same format and structure instead.


# Editing and export problems
Source: https://docs.presenton.ai/troubleshooting/editing-and-export

Recover missing edits and fix AI editing, PPTX, PDF, font, and layout problems.

## My latest changes are missing

1. Stop editing and refresh the presentation to check its latest saved state.
2. Confirm that you opened the correct presentation and account.
3. If the presentation is shared or duplicated, make sure you are editing the intended copy.
4. Duplicate the recovered presentation before making more changes if you are unsure which state is current.

## An AI edit changes too much or targets the wrong item

* Select the slide or object you want to change before opening the assistant.
* Ask for one specific change at a time.
* Identify what must remain unchanged, such as the slide layout, wording, colors, or other objects.
* Undo an unwanted result before sending a more precise instruction.

For example: `On slide 4, shorten the selected paragraph to three bullets. Keep the figures, title, and layout unchanged.`

## Export does not finish

* Wait for any active generation or editing task to complete.
* Refresh the presentation, then try the export once more.
* Test a short presentation in the same format. If it exports, duplicate the affected presentation and remove groups of slides to identify the problematic slide.
* Try the other export format to determine whether the problem affects PPTX, PDF, or both.

## The exported file looks different

* Open the file in the application your audience will use. PowerPoint, browser previews, and PDF viewers can render the same file differently.
* Check for text overflow, cropped images, substituted fonts, chart labels, table widths, and objects outside slide boundaries before export.
* Replace unavailable custom fonts with common fonts, or ask the workspace administrator whether the required fonts are installed.
* Compare the exported result with Presenton's editor preview and note the slide numbers where they differ.

## If you manage a self-hosted instance

* Confirm `/app_data` is writable and has enough free disk space.
* Check application and rendering logs when AI edits or exports fail.
* Verify the export runtime can reach its internal render page and required assets.
* Check available memory and confirm custom fonts are available to the renderer.


# Presentation generation problems
Source: https://docs.presenton.ai/troubleshooting/generation

Fix generation that will not start, takes too long, fails, or produces an unexpected presentation.

## Generation does not start

1. Make sure the prompt explains the presentation topic and that every required option has been selected.
2. Wait for attached files to finish uploading or processing before selecting **Generate**.
3. Refresh Presenton, start a new presentation, and retry with a short prompt and a small slide count.
4. If that works, add the original files and settings back one at a time to find what causes the problem.

## Generation takes too long or stops

* Do not repeatedly select **Generate**; this can start duplicate work.
* Try fewer slides and a smaller source file.
* If one file is very large, include only the pages or sheets needed for the presentation.
* Note whether the process stops during file processing, outline creation, slide generation, image selection, or final rendering. This detail helps support locate the failure.

## The presentation was created, but the result is not right

* State the audience, purpose, tone, and desired outcome directly in the prompt.
* Review the outline before generating slides. Correct missing topics, ordering, or emphasis there first.
* Ask for exact facts to be preserved and avoid asking Presenton to infer figures that are not in the source.
* Use a source with clear headings and readable text when the presentation misses important details.
* Regenerate only after changing the prompt, outline, source, or settings; retrying the same input may produce a similar result.

## A file-based presentation fails

Try the same prompt without the file. If it works, open the source file on your computer, confirm it is not password protected, and upload a smaller copy. See [Files, content, and images](/troubleshooting/content-and-media) for format and extraction checks.

## If you manage a self-hosted instance

* Verify the selected text provider URL, model name, credentials, network access, and account quota.
* Confirm the model meets the structured-output and context requirements for the installed Presenton release.
* Check application logs for provider, schema, rate-limit, timeout, rendering, storage, or memory errors.
* Confirm `/app_data` is writable, has sufficient free space, and persists across container restarts.

If generation fails for every user with a small known-good prompt, the problem is likely deployment-wide. If it fails for only one prompt, presentation, or file, preserve a sanitized copy of that input for testing.


# Hosting problems
Source: https://docs.presenton.ai/troubleshooting/hosting

Fix self-hosted installation, startup, persistence, and provider failures.

<Info>
  This page is for administrators of self-hosted Presenton. If you use Presenton Cloud, return to the main [Troubleshooting guide](/troubleshooting).
</Info>

## Application does not open

Confirm the container is running, the configured host port is free, and traffic is published to container port `80`. Review container logs for startup failures.

## Presentations or settings disappeared

Confirm the replacement container mounts the same persistent host directory to `/app_data`. A container without that mount starts with empty application data.

## Provider cannot connect

* Verify the provider URL, model, and credentials.
* Test the provider outside Presenton when possible.
* Use a hostname reachable from inside the container.
* Confirm the required model is installed and running.

## Authentication callback fails

Confirm all required callback ports are published and reachable from the browser performing authentication. Check that another process is not already using the configured port.

## Before upgrading

Back up `/app_data`, pin the new image tag, review release notes, and test providers, templates, API integrations, editing, and export before replacing production.


# Troubleshooting
Source: https://docs.presenton.ai/troubleshooting/index

Solve common problems while creating, editing, and exporting presentations or using Presenton integrations.

This section is for everyone who uses Presenton. Start with what you can see in the app; you do not need server access or technical logs for the first checks. Separate guidance is included for workspace administrators, self-hosted operators, and API developers when they need it.

## Before you retry

1. Save or duplicate the presentation if you can, especially before testing a different template or removing content.
2. Copy the exact error message and note what you clicked immediately before it appeared.
3. Refresh Presenton, reopen the presentation, and try the action once more.
4. If the problem continues, try a smaller prompt, file, or presentation to see whether it affects one item or everything.
5. Keep passwords, API keys, private documents, and confidential presentation content out of screenshots and support messages.

<Tip>
  If you use Presenton Cloud, follow the user checks on each page. Instructions involving Docker, `/app_data`, providers, or logs are only for someone who manages a self-hosted instance.
</Tip>

## Choose what went wrong

<CardGroup>
  <Card title="Presentation will not generate" icon="wand-magic-sparkles" href="/troubleshooting/generation">
    Fix generation that will not start, takes too long, fails, or produces an unexpected result.
  </Card>

  <Card title="Files, content, or images are wrong" icon="file-image" href="/troubleshooting/content-and-media">
    Fix uploads, missing source content, unreadable files, and image problems.
  </Card>

  <Card title="Editing or export is not working" icon="file-export" href="/troubleshooting/editing-and-export">
    Recover missing edits and solve AI editing, PPTX, PDF, font, and layout problems.
  </Card>

  <Card title="Cannot sign in or find my work" icon="user-lock" href="/troubleshooting/account-and-access">
    Check the account, workspace, deployment, and access method you are using.
  </Card>

  <Card title="Self-hosted Presenton is unavailable" icon="server" href="/troubleshooting/hosting">
    Diagnose installation, startup, storage, and provider problems as an administrator.
  </Card>

  <Card title="API or integration is failing" icon="brackets-curly" href="/troubleshooting/api-and-integrations">
    Diagnose authentication, tasks, webhooks, and MCP as a developer.
  </Card>

  <Card title="I still need help" icon="life-ring" href="/troubleshooting/support">
    Collect the right details and report the problem without exposing private information.
  </Card>
</CardGroup>


# Report an issue or contact support
Source: https://docs.presenton.ai/troubleshooting/support

Collect useful diagnostics and ask for help safely.

If the user checks did not solve the problem, send enough detail for someone else to reproduce it. You do not need server logs when you use Presenton Cloud or do not manage the self-hosted server.

## Include these details

* Whether you use Presenton Cloud, the desktop app, or a self-hosted server
* Your browser or desktop operating system and, if known, the Presenton version
* What you were trying to do and the exact step that failed
* Expected behavior, actual behavior, and whether the same test previously worked
* The exact error text and a screenshot with private information removed
* When it happened and whether it affects one presentation, one file, or everything
* A small, safe example that reproduces the problem, when possible
* For administrators or developers: sanitized logs, HTTP status, request identifier, task state, deployment method, and provider

## Do not include

* API tokens, passwords, cookies, private keys, signed URLs, or authentication headers
* Provider secrets, database credentials, or complete environment files
* Confidential source documents, presentation content, customer data, or internal screenshots
* Personal information, access details, or production logs unrelated to the problem

For product support, email [suraj@presenton.ai](mailto:suraj@presenton.ai). For reproducible Open Source issues, use the [Presenton GitHub repository](https://github.com/presenton/presenton) after removing secrets and private data. Replace sensitive values with placeholders and create a small sanitized source file when reproduction requires an input.


# Presenton Documentation
Source: https://docs.presenton.ai/index

Create, edit, automate, and operate Presenton across Cloud and self-hosted deployments.

<div>
  <section>
    <div>Build with <span>Presenton</span></div>
    <p>Editable presentation workflows for prompts, files, templates, and APIs.</p>
  </section>

  <section aria-label="Presenton documentation paths">
    <div>
      <a href="/general/overview" aria-label="Understand Presenton" />

      <div>
        <img alt="" />

        <img alt="" />
      </div>

      <div>
        <p>Understand Presenton</p>
        <p>Start with the product overview, workflow, core concepts, deployment modes, and feature availability.</p>
      </div>
    </div>

    <div>
      <a href="/user-guide/create-new-presentation" aria-label="Create and edit decks" />

      <div>
        <img alt="" />

        <img alt="" />
      </div>

      <div>
        <p>Create and edit decks</p>
        <p>Generate a first draft, refine slides, work with content blocks, and export to PPTX or PDF.</p>
      </div>
    </div>

    <div>
      <a href="/user-guide/branding-and-design/templates" aria-label="Use reusable templates" />

      <div>
        <img alt="" />

        <img alt="" />
      </div>

      <div>
        <p>Use reusable templates</p>
        <p>Bring existing presentation designs into repeatable templates for consistent, editable output.</p>
      </div>
    </div>

    <div>
      <a href="/hosting/overview" aria-label="Run Presenton yourself" />

      <div>
        <img alt="" />

        <img alt="" />
      </div>

      <div>
        <p>Run Presenton yourself</p>
        <p>Install Presenton with Docker, configure providers, and explore support for custom enterprise requirements.</p>
      </div>
    </div>

    <div>
      <a href="/user-guide/api-and-automation/overview" aria-label="Build with the API" />

      <div>
        <img alt="" />

        <img alt="" />
      </div>

      <div>
        <p>Build with the API</p>
        <p>Generate, track, edit, and export presentations from your product, automation, or internal workflow.</p>
      </div>
    </div>

    <div>
      <a href="/troubleshooting" aria-label="Troubleshoot and compare versions" />

      <div>
        <img alt="" />

        <img alt="" />
      </div>

      <div>
        <p>Troubleshoot and compare versions</p>
        <p>Diagnose generation, editing, export, hosting, and integration issues, or open a frozen documentation snapshot.</p>
      </div>
    </div>
  </section>
</div>


# Presenton Documentation
Source: https://docs.presenton.ai/index

Create, edit, automate, and operate Presenton across Cloud and self-hosted deployments.

<div>
  <section>
    <div>Build with <span>Presenton</span></div>
    <p>Editable presentation workflows for prompts, files, templates, and APIs.</p>
  </section>

  <section aria-label="Presenton documentation paths">
    <div>
      <a href="/general/overview" aria-label="Understand Presenton" />

      <div>
        <img alt="" />

        <img alt="" />
      </div>

      <div>
        <p>Understand Presenton</p>
        <p>Start with the product overview, workflow, core concepts, deployment modes, and feature availability.</p>
      </div>
    </div>

    <div>
      <a href="/user-guide/create-new-presentation" aria-label="Create and edit decks" />

      <div>
        <img alt="" />

        <img alt="" />
      </div>

      <div>
        <p>Create and edit decks</p>
        <p>Generate a first draft, refine slides, work with content blocks, and export to PPTX or PDF.</p>
      </div>
    </div>

    <div>
      <a href="/user-guide/branding-and-design/templates" aria-label="Use reusable templates" />

      <div>
        <img alt="" />

        <img alt="" />
      </div>

      <div>
        <p>Use reusable templates</p>
        <p>Bring existing presentation designs into repeatable templates for consistent, editable output.</p>
      </div>
    </div>

    <div>
      <a href="/hosting/overview" aria-label="Run Presenton yourself" />

      <div>
        <img alt="" />

        <img alt="" />
      </div>

      <div>
        <p>Run Presenton yourself</p>
        <p>Install Presenton with Docker, configure providers, and explore support for custom enterprise requirements.</p>
      </div>
    </div>

    <div>
      <a href="/user-guide/api-and-automation/overview" aria-label="Build with the API" />

      <div>
        <img alt="" />

        <img alt="" />
      </div>

      <div>
        <p>Build with the API</p>
        <p>Generate, track, edit, and export presentations from your product, automation, or internal workflow.</p>
      </div>
    </div>

    <div>
      <a href="/troubleshooting" aria-label="Troubleshoot and compare versions" />

      <div>
        <img alt="" />

        <img alt="" />
      </div>

      <div>
        <p>Troubleshoot and compare versions</p>
        <p>Diagnose generation, editing, export, hosting, and integration issues, or open a frozen documentation snapshot.</p>
      </div>
    </div>
  </section>
</div>


# Presenton Documentation
Source: https://docs.presenton.ai/index

Create, edit, automate, and operate Presenton across Cloud and self-hosted deployments.

<div>
  <section>
    <div>Build with <span>Presenton</span></div>
    <p>Editable presentation workflows for prompts, files, templates, and APIs.</p>
  </section>

  <section aria-label="Presenton documentation paths">
    <div>
      <a href="/general/overview" aria-label="Understand Presenton" />

      <div>
        <img alt="" />

        <img alt="" />
      </div>

      <div>
        <p>Understand Presenton</p>
        <p>Start with the product overview, workflow, core concepts, deployment modes, and feature availability.</p>
      </div>
    </div>

    <div>
      <a href="/user-guide/create-new-presentation" aria-label="Create and edit decks" />

      <div>
        <img alt="" />

        <img alt="" />
      </div>

      <div>
        <p>Create and edit decks</p>
        <p>Generate a first draft, refine slides, work with content blocks, and export to PPTX or PDF.</p>
      </div>
    </div>

    <div>
      <a href="/user-guide/branding-and-design/templates" aria-label="Use reusable templates" />

      <div>
        <img alt="" />

        <img alt="" />
      </div>

      <div>
        <p>Use reusable templates</p>
        <p>Bring existing presentation designs into repeatable templates for consistent, editable output.</p>
      </div>
    </div>

    <div>
      <a href="/hosting/overview" aria-label="Run Presenton yourself" />

      <div>
        <img alt="" />

        <img alt="" />
      </div>

      <div>
        <p>Run Presenton yourself</p>
        <p>Install Presenton with Docker, configure providers, and explore support for custom enterprise requirements.</p>
      </div>
    </div>

    <div>
      <a href="/user-guide/api-and-automation/overview" aria-label="Build with the API" />

      <div>
        <img alt="" />

        <img alt="" />
      </div>

      <div>
        <p>Build with the API</p>
        <p>Generate, track, edit, and export presentations from your product, automation, or internal workflow.</p>
      </div>
    </div>

    <div>
      <a href="/troubleshooting" aria-label="Troubleshoot and compare versions" />

      <div>
        <img alt="" />

        <img alt="" />
      </div>

      <div>
        <p>Troubleshoot and compare versions</p>
        <p>Diagnose generation, editing, export, hosting, and integration issues, or open a frozen documentation snapshot.</p>
      </div>
    </div>
  </section>
</div>


# Presenton Documentation
Source: https://docs.presenton.ai/index

Create, edit, automate, and operate Presenton across Cloud and self-hosted deployments.

<div>
  <section>
    <div>Build with <span>Presenton</span></div>
    <p>Editable presentation workflows for prompts, files, templates, and APIs.</p>
  </section>

  <section aria-label="Presenton documentation paths">
    <div>
      <a href="/general/overview" aria-label="Understand Presenton" />

      <div>
        <img alt="" />

        <img alt="" />
      </div>

      <div>
        <p>Understand Presenton</p>
        <p>Start with the product overview, workflow, core concepts, deployment modes, and feature availability.</p>
      </div>
    </div>

    <div>
      <a href="/user-guide/create-new-presentation" aria-label="Create and edit decks" />

      <div>
        <img alt="" />

        <img alt="" />
      </div>

      <div>
        <p>Create and edit decks</p>
        <p>Generate a first draft, refine slides, work with content blocks, and export to PPTX or PDF.</p>
      </div>
    </div>

    <div>
      <a href="/user-guide/branding-and-design/templates" aria-label="Use reusable templates" />

      <div>
        <img alt="" />

        <img alt="" />
      </div>

      <div>
        <p>Use reusable templates</p>
        <p>Bring existing presentation designs into repeatable templates for consistent, editable output.</p>
      </div>
    </div>

    <div>
      <a href="/hosting/overview" aria-label="Run Presenton yourself" />

      <div>
        <img alt="" />

        <img alt="" />
      </div>

      <div>
        <p>Run Presenton yourself</p>
        <p>Install Presenton with Docker, configure providers, and explore support for custom enterprise requirements.</p>
      </div>
    </div>

    <div>
      <a href="/user-guide/api-and-automation/overview" aria-label="Build with the API" />

      <div>
        <img alt="" />

        <img alt="" />
      </div>

      <div>
        <p>Build with the API</p>
        <p>Generate, track, edit, and export presentations from your product, automation, or internal workflow.</p>
      </div>
    </div>

    <div>
      <a href="/troubleshooting" aria-label="Troubleshoot and compare versions" />

      <div>
        <img alt="" />

        <img alt="" />
      </div>

      <div>
        <p>Troubleshoot and compare versions</p>
        <p>Diagnose generation, editing, export, hosting, and integration issues, or open a frozen documentation snapshot.</p>
      </div>
    </div>
  </section>
</div>


# Presenton Documentation
Source: https://docs.presenton.ai/index

Create, edit, automate, and operate Presenton across Cloud and self-hosted deployments.

<div>
  <section>
    <div>Build with <span>Presenton</span></div>
    <p>Editable presentation workflows for prompts, files, templates, and APIs.</p>
  </section>

  <section aria-label="Presenton documentation paths">
    <div>
      <a href="/general/overview" aria-label="Understand Presenton" />

      <div>
        <img alt="" />

        <img alt="" />
      </div>

      <div>
        <p>Understand Presenton</p>
        <p>Start with the product overview, workflow, core concepts, deployment modes, and feature availability.</p>
      </div>
    </div>

    <div>
      <a href="/user-guide/create-new-presentation" aria-label="Create and edit decks" />

      <div>
        <img alt="" />

        <img alt="" />
      </div>

      <div>
        <p>Create and edit decks</p>
        <p>Generate a first draft, refine slides, work with content blocks, and export to PPTX or PDF.</p>
      </div>
    </div>

    <div>
      <a href="/user-guide/branding-and-design/templates" aria-label="Use reusable templates" />

      <div>
        <img alt="" />

        <img alt="" />
      </div>

      <div>
        <p>Use reusable templates</p>
        <p>Bring existing presentation designs into repeatable templates for consistent, editable output.</p>
      </div>
    </div>

    <div>
      <a href="/hosting/overview" aria-label="Run Presenton yourself" />

      <div>
        <img alt="" />

        <img alt="" />
      </div>

      <div>
        <p>Run Presenton yourself</p>
        <p>Install Presenton with Docker, configure providers, and explore support for custom enterprise requirements.</p>
      </div>
    </div>

    <div>
      <a href="/user-guide/api-and-automation/overview" aria-label="Build with the API" />

      <div>
        <img alt="" />

        <img alt="" />
      </div>

      <div>
        <p>Build with the API</p>
        <p>Generate, track, edit, and export presentations from your product, automation, or internal workflow.</p>
      </div>
    </div>

    <div>
      <a href="/troubleshooting" aria-label="Troubleshoot and compare versions" />

      <div>
        <img alt="" />

        <img alt="" />
      </div>

      <div>
        <p>Troubleshoot and compare versions</p>
        <p>Diagnose generation, editing, export, hosting, and integration issues, or open a frozen documentation snapshot.</p>
      </div>
    </div>
  </section>
</div>