canonical: https://jentic.com/apis/gamma.app/gamma

# Gamma App Gamma API

Jentic publishes the only available OpenAPI specification for Gamma API, keeping it validated and agent-ready. Gamma is an AI-powered presentation, document, and webpage generator that turns prompts, outlines, or templates into formatted decks within minutes. The API exposes generation jobs (text-to-deck and template-based), poll-status retrieval, and access to workspace themes and folders so agents can produce branded content programmatically. It is well-suited for automating internal briefings, sales decks, and report packs that previously required manual slide editing.

## For AI agents

Generate presentations, documents, and webpages from natural-language input, then poll for completion and pull workspace themes and folders.

## Scope

Does not handle video editing, image generation, or document collaboration - use for AI presentation and deck generation only.

## Capabilities

- Generate a multi-slide presentation from a text prompt with control over card count, format, and export type
- Create a deck from an existing Gamma template by submitting structured inputs to `/generations/from-template`
- Poll long-running generation jobs at `/generations/{id}` until the asset is ready for download
- List workspace themes to apply consistent branding across generated decks
- Browse workspace folders to organise generated outputs by team or project

## Use cases

### Automated Sales Decks From CRM Notes

Convert raw sales call notes or CRM activity logs into a polished prospect-facing deck without a design pass. The agent posts the notes to /generations with a chosen theme and card count, polls `/generations/{id}` until status is complete, and returns the export URL. Reps get a tailored deck per opportunity in minutes instead of hours.

Example prompt: Call POST /generations with inputText set to the call summary, numCards 8, and a chosen theme id, then poll GET `/generations/{id}` every 5 seconds until status is complete and return the export URL

### Scheduled Internal Briefings

Produce recurring leadership or all-hands briefing decks from structured weekly metrics. The agent renders a markdown digest, posts to `/generations/from-template` using a saved template, and drops the resulting deck into a designated folder. Saves a 1-2 hour design cycle each week.

Example prompt: Call POST `/generations/from-template` with the weekly-update template id and the JSON payload of metrics, then return the deck URL once `/generations/{id}` reports a completed status

### On-Demand Customer Onboarding Material

Generate per-customer onboarding decks that reference the customer name, plan tier, and goals. Agents pull theme ids from /themes to enforce brand consistency, generate the deck, and place it in a customer folder via /folders. Customer success teams ship personalised material at the speed of email replies.

Example prompt: Fetch /themes to find the brand theme id, then POST /generations with the onboarding prompt, themeId, and exportAs pdf, polling until ready

### Agent-Driven Content Generation Through Jentic

AI agents discover Gamma through Jentic intent search, load the generation operation schema, and produce decks as part of larger workflows (lead qualification, RFP responses, executive summaries). Jentic isolates the X-API-KEY in its vault so the agent never handles the raw secret. Integration goes from days of bespoke API code to a sub-hour search-load-execute flow.

Example prompt: Use Jentic search query 'generate a presentation from text' to load the gamma_generate_presentation tool, then execute with inputText and numCards parameters

## Key endpoints

| Method | Path | Description |
| --- | --- | --- |
| POST | `/generations` | Generate a presentation from text |
| POST | `/generations/from-template` | Generate a presentation from a saved template |
| GET | `/generations/{id}` | Poll a generation job's status |
| GET | `/themes` | List workspace themes |
| GET | `/folders` | List workspace folders |

## Key resources

- **Generations** — Create text and template-based generation jobs and poll their status
- **Themes** — List workspace themes available for applying branding to decks
- **Folders** — List workspace folders for organising generated assets

## Why Jentic

- **Setup:** Wiring the Gamma API by hand means setting up its X-API-KEY header auth against public-api.gamma.app and polling generation status calls yourself. Through Jentic you install once, import the Gamma API from the API Directory, store the key once, and your agent calls it.
- **Permission scoping:** Gamma puts the generation id in the URL path (`/generations/{id}`), so a rule can pin your agent to reading one generation: it can fetch that generation's status and nothing else. You choose the operations it may call, so starting a new generation is not included unless you add it.
- **Credential handling:** Your Gamma API key is stored once, encrypted, by your own Jentic One instance and injected at execution time. It never enters the agent's prompt, logs, or context.
- **Discovery method:** Agents search Jentic by intent such as 'generate a presentation from a prompt' or 'check a Gamma generation's status', and Jentic returns the matching Gamma API operation with its input schema so the agent calls the right endpoint without browsing the reference docs.

## Related APIs

- **Canva Connect API** — Canva offers presentation and design automation with a richer template library, while Gamma focuses on AI-first deck generation from prompts.
- **OpenAI API** — Use OpenAI to draft and refine the inputText before passing it to Gamma's /generations endpoint.
- **Slack API** — Post the Gamma deck export URL into a Slack channel so the team is notified the moment a generation completes.

## FAQ

### Why is there no official OpenAPI spec for Gamma API?

Gamma does not publish an OpenAPI specification. Jentic generates and maintains this spec so that AI agents and developers can call Gamma API via structured tooling. It is validated against the live API and kept up to date. Get started with Jentic One, the self-hosted execution layer.

### What authentication does the Gamma API use?

Gamma uses an API key passed in the X-API-KEY header. When called through Jentic the key is stored encrypted in your Jentic One instance and injected at execution time, so the agent context never sees the raw secret.

### Can I generate a presentation from a template with the Gamma API?

Yes. POST `/generations/from-template` accepts a template id with structured input fields, returning a generation job that you then poll at GET `/generations/{id}` until its status is complete.

### How do I check whether a Gamma generation has finished?

Generation is asynchronous. After POST /generations returns the job id, call GET `/generations/{id}` on a polling interval (every few seconds is typical) and read the status field; the export URL is available once the job is complete.

### What are the rate limits for the Gamma API?

Gamma's published OpenAPI does not declare formal rate-limit headers, so back off on HTTP 429 responses and check your workspace plan limits in the Gamma dashboard before scheduling high-volume generation jobs.

### How do I generate a deck through Jentic?

Install with pip install jentic, search 'generate a presentation from text' to find the Gamma generation operation, load its schema, and execute with your inputText, numCards, and themeId. Jentic returns the export URL once the job is complete.

### Can I limit what my agent is allowed to do with the Gamma API?

Yes. Because you self-host Jentic One, your own rules decide which Gamma operations and credentials the agent may use. Since Gamma puts the generation id in the URL path at `/generations/{id}`, you can pin the agent to reading one generation's status and nothing else, while leaving out starting a new generation via POST /generations, listing /themes, or browsing /folders. The agent can only call the operations you explicitly allow.