canonical: https://jentic.com/apis/elevio.help/elevio

# Elevio Help Elevio API

Jentic publishes the only available OpenAPI specification for Elevio API, keeping it validated and agent-ready. Elevio is a customer-education and self-service platform, and its API exposes 10 endpoints for managing knowledge-base content programmatically. Articles and categories are the two top-level resources, each supporting list, create, retrieve, update, and delete operations. Authentication is a single API key passed in the X-API-Key request header against https://api.elevio.help/v1.

## For AI agents

Manage Elevio knowledge-base articles and categories: list, create, retrieve, update, and delete content. Authenticated with an API key in the X-API-Key header.

## Scope

Does not handle support tickets, live chat, customer messaging, or in-app announcements - use for Elevio knowledge-base article and category management only.

## Capabilities

- List, create, update, and delete knowledge-base articles via /articles
- Organise content into categories using full CRUD on /categories
- Retrieve a single article by ID for in-product help embedding
- Bulk-update article bodies during a content migration or re-platform
- Delete deprecated categories without disrupting article URLs
- Programmatically seed an Elevio knowledge base from existing markdown sources

## Use cases

### Knowledge Base Content Management

Drive an Elevio knowledge base from a source-of-truth content repository. Authoring tools push article changes to `/articles/{articleId}`, restructure information architecture via /categories, and remove stale content with DELETE. With 10 CRUD endpoints across articles and categories, the API is enough to run a knowledge base headlessly without using the Elevio admin UI.

Example prompt: Create a new article titled 'How to reset your password' in category_id=42, then retrieve it by ID to confirm the body was saved

### Documentation Migration

Move existing help content from a legacy CMS or markdown repo into Elevio by scripting bulk creation of categories and articles. The list endpoints return existing content for diffing, and create endpoints accept full article bodies, which lets a migration tool run idempotently and resume from the last successful article.

Example prompt: Read the list of articles in the source system, create matching categories in Elevio, then create each article assigning it to the correct category_id

### In-Product Help Personalisation

Power an in-product help widget that fetches the right Elevio article based on the user's current page or feature. The application calls GET `/articles/{articleId}` on demand and renders the article body inline. With only 10 endpoints to learn, the integration is small enough to be wrapped in a thin client and cached aggressively.

Example prompt: Fetch article_id=123 via GET `/articles/{articleId}` and render the body in the customer's settings page

### AI Agent Integration via Jentic

Build an AI documentation agent that drafts a new help article from a support ticket trend, posts it to Elevio, and links it back into the ticket as the canonical answer. Through Jentic, the agent searches by intent, loads the POST /articles schema, and writes without holding the Elevio API key in its prompt.

Example prompt: Search Jentic for 'create an Elevio article', load the schema for POST /articles, and publish a draft article titled 'Refund policy' with a generated body

## Key endpoints

| Method | Path | Description |
| --- | --- | --- |
| GET | `/articles` | List all articles |
| POST | `/articles` | Create an article |
| GET | `/articles/{articleId}` | Get an article by ID |
| PUT | `/articles/{articleId}` | Update an article |
| DELETE | `/articles/{articleId}` | Delete an article |
| GET | `/categories` | List all categories |
| POST | `/categories` | Create a category |

## Key resources

- **Articles** — List, create, retrieve, update, and delete knowledge-base articles
- **Categories** — List, create, retrieve, update, and delete categories that group articles

## Why Jentic

- **Setup:** Wiring Elevio by hand means handling its API-key auth, setting the X-API-Key header on every call, and mapping article and category operations yourself. Through Jentic you install once, import the Elevio API from the API Directory, store the API key once, and your agent calls it.
- **Permission scoping:** Elevio puts the article id in the URL path (`/articles/{articleId}`), so a rule can pin your agent to one article for reads and updates. You choose the operations it may call, so DELETE `/articles/{articleId}` or category creation are not included unless you add them.
- **Credential handling:** Your Elevio 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 'create a help article' or 'list all categories', and Jentic returns the matching Elevio operation with its input schema so the agent calls the right endpoint without browsing the reference docs.

## Related APIs

- **Zendesk API** — Zendesk Guide is a help-center alternative bundled with a full ticketing suite
- **Intercom API** — Intercom Articles competes with Elevio for in-app help content
- **Freshdesk API** — Freshdesk handles tickets while Elevio holds the canonical knowledge base

## FAQ

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

Elevio publishes its API reference as standalone HTML at api-docs.elevio.help rather than a versioned OpenAPI specification. Jentic generates and maintains this spec so AI agents and developers can call Elevio 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 Elevio API use?

Elevio uses a single API key passed in the X-API-Key request header. Through Jentic, the key is stored encrypted in the vault and never appears in the agent's prompt; the agent receives a scoped, short-lived handle for each call.

### Can I create articles with the Elevio API?

Yes. POST /articles creates a new article and accepts a JSON body containing the title, content, and category assignment. The same endpoint group exposes GET, PUT, and DELETE on `/articles/{articleId}` so a content-management workflow can run end-to-end.

### Does the Elevio API support categories?

Yes. /categories supports full CRUD: GET to list, POST to create, GET `/categories/{categoryId}` to fetch one, PUT to update, and DELETE to remove. Articles reference categories by ID at create or update time.

### How do I publish a new help article through Jentic?

Run the Jentic search query 'create an Elevio article', load the input schema for POST /articles, then execute with the article body and category_id. Jentic handles the X-API-Key injection so the call succeeds without the agent seeing the raw key.

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

The published OpenAPI spec does not declare numeric rate limits. Treat the API as bursty-tolerant for content-management workloads but throttle concurrency during bulk migrations, and check the X-RateLimit-Remaining header on responses if Elevio adds one.

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

Yes. Jentic One is self-hosted, so you run it and your own rules decide which Elevio operations and credentials the agent may use. Because the article id sits in the URL path at `/articles/{articleId}`, you can pin the agent to reading or updating a single article, and you choose the operations it may call, so DELETE `/articles/{articleId}` or category creation stay off unless you add them. The Elevio API key stays in your instance and is injected only for the calls you have allowed.