CKEditor AI: Configuration and API

Custom LLM Integration, Programmatic Control, and MCP Support

CKEditor AI gives you a fully configurable integration layer that plugs into your existing stack. Automate content workflows, run Quick Actions, Review, and Chat straight from your application code. Connect leading models from any major provider or your own private endpoint, pull live context from your internal systems through MCP, and define exactly what the AI does with your content, with full visibility over usage and cost.

All the control, none of the build and maintain.

Front-end and REST API calls flowing between the editor and CKEditor AI

API and
Programmatic Control

CKEditor AI is built on a sophisticated backend that operates on HTML instead of plain text, understands that it's working inside a rich text editor with its own structure and features, and returns clean output that merges back into the editor.

The same backend is exposed to you through two APIs: a front-end plugin API and a REST API. Use them to automate workflows, build custom experiences, or run it server-side – all by configuring the backend, not building and maintaining an editor-aware AI layer yourself. No provider changes to track, no model deprecations to chase, no output parsing to keep clean: that's the effort you'll spend once on configuration, not continuously on upkeep.

How to use CKEditor AI APIs
programmatically

Run AI prompts programmatically

The Frontend Editor API lets you execute AI prompts directly from your application. A single prompt can rewrite and restructure an entire document without opening AI Chat. See the full API reference.

Loading...
Generate meta title and meta description from the browser

The Actions endpoint runs stateless transforms on any content you pass to it, with responses streamed over Server-Sent Events. This demo calls it from the browser to generate a title and a meta description for a blog post. The same call works from your backend. See the full API reference.

Loading...
Server-side document pipeline

The Document Processing endpoint takes a prompt and an HTML document and returns a transformed version. It is designed for server-side workflows like CMS publish hooks, content pipelines, and batch translation. This demo runs the flow in the browser for visibility, but the same call is at home in your backend. This endpoint is experimental. See the full API reference.

Loading...
Note
  • This demo contains just a small subset of available CKEditor features. You are free to add more features to CKEditor regardless what editor type/toolbar you choose.

  • Read more about the AI programmatic capabilities in the documentation.

Drive AI from your application code

Wire any CKEditor AI feature to your own triggers and UI. Build a custom experience
around Chat, run Review and Quick Actions from your application logic, and reach
AI capabilities the toolbar doesn't expose:

AI Chat

Send messages, start new conversations, inject dynamic context, and add editor selections as chat context. Use this to pre-populate the chat with application state, personalize interactions with user-specific data, or trigger conversations from your own UI.

AI Review

Trigger reviews from your code and choose whether the results appear through the editor UI or run entirely in the background. Background review is useful for automated quality checks on publish, pre-submit validation workflows, or any case where you need AI feedback without user involvement. Apply results as tracked suggestions or direct edits.

Quick Actions

Execute any configured AI action against the current editor selection without user interaction. Useful for automating repetitive transformations as part of your editorial workflow.

REST API for backend
and server-side use

Run CKEditor AI without an editor instance on the page at all – from any backend, headless, on your own schedule. Drop it into automation pipelines: generate metadata at publish time, run compliance checks on every submission, or process entire content libraries in bulk with four types of operations:

Actions

Stateless, single-turn content transformations.

Conversations

Multi-turn AI dialogue with session history.

Reviews

Document analysis and structured feedback.

Document Processing

Whole-document transformations that return clean, structured output.

Server-side editor API

The server-side editor API executes CKEditor code – editor, plugins, and AI gateways – through API endpoints, so you drive AI with the same front-end API you'd use in the browser, headless and against a live collaboration document.

Edit open documents

Apply a transformation while users have the document open, and the change shows up for all of them in real time.

Keep a human in the loop

Write AI output back as track changes suggestions, so a reviewer accepts or rejects every change.

Trigger AI from backend events

Run reviews, translations, or rewrites from publish hooks, scheduled jobs, or CMS save actions.

Transform documents in bulk

Apply one operation across many documents at once, like translating an entire knowledge base or aligning tone across every article.

On-Premises and
Self-Hosted Deployment

Run the entire CKEditor AI service inside your own infrastructure

The full feature set – AI Chat, Quick Actions, Review, Translate, Document Processing, and MCP – runs on your servers, distributed as Docker images that deploy in any environment that runs containers.

Everything stays within your perimeter

Once the service is set up, there's zero data egress to CKEditor, and all conversations and documents are encrypted at rest. Your frontend code stays the same whichever models you run behind it.

On-premises is the right choice

When your security posture requires data to stay within your walls, when you want to bring your own models, including fine-tuned ones trained on proprietary data, or when enterprise policy rules out third-party API calls for sensitive content.

Bring Your Own LLM
Connect Any OpenAI
API-Compatible
Endpoint

Integrating LLMs into an editing workflow typically means managing separate SDKs, provider-specific parsing, and individual security reviews for each model provider, with no clean way to switch without rewriting code. CKEditor AI eliminates that with a single OpenAI API-compatible endpoint interface.

On the on-premises deployment, you can point CKEditor AI at your own models instead of the curated cloud set – whether you need data sovereignty, want to run a fine-tuned model, or already have an internal LLM platform. This is custom LLM integration without the per-provider plumbing: models you configure server-side appear automatically in the editor's model selector.

What you can connect:

Any OpenAI API-compatible endpoint

Self-hosted or fine-tuned models, private deployments of open-source models, custom inference servers, or gateways like OpenRouter and Together AI

Major cloud model platforms

Amazon Bedrock, Azure OpenAI, and Google Vertex AI, including Gemini and Anthropic models

Your own provider keys

For OpenAI, Anthropic, and Google, so requests run on your accounts and never route through CKEditor servers

What you get:

Your data stays in your infrastructure

Queries run inside your security perimeter, and conversations and documents are encrypted at rest

One output format across every model

No model-specific parsing in your frontend, whichever provider you use

No vendor lock-in

Switch models or providers by changing a config value, not your codebase

Supported AI Providers and Models

CKEditor AI ships with curated models from OpenAI, Anthropic, and Google, ready to use out of the box. Auto/Agent mode picks the best model for each task automatically, balancing quality, speed, and cost, so your users get strong results without choosing a model at all. The list grows as new models ship – see the supported models in the docs.

  • Claude Opus 4.8
  • Claude Opus 5
  • Claude Opus 5.5
  • Claude Fable 5
  • Claude Fable 5.1
  • Claude Opus 4.7
  • Claude 5.5 Sonnet
  • Claude 5 Sonnet
  • Claude 4.6 Sonnet
  • Claude 5.5 Haiku
  • Claude 4.5 Haiku
  • Gemini 3.1 Pro
  • Gemini 4 Argon
  • Gemini 2.5 Flash
  • Gemini 3 Flash
  • Gemini 3.5 Flash
  • Gemini 3.6 Flash
  • Gemini 3.7 Flash
  • Gemini 3.8 Flash
  • GPT-6 Astra
  • GPT-6 Sol
  • GPT-6 Luna
  • GPT-5.6 Sol
  • GPT-5.6 Terra
  • GPT-5.6 Luna
  • GPT-5.5
  • GPT-5.4
  • GPT-5.2
  • GPT-5.1
  • GPT-5
  • GPT-4.1
  • GPT-5 Mini
  • GPT-5.4 Mini
  • GPT-4.1 Mini

Need a specific provider, a private deployment, or your own fine-tuned model? See Bring Your Own LLM.

MCP Integration

Model Context Protocol (MCP) support lets CKEditor AI reach beyond the document and its training data into your live systems. Mid-conversation, the AI decides which tools to call: querying your CRM, searching an internal knowledge base, or calling your own APIs. It then uses what it finds to draft and edit content – without the user ever leaving the editor. CKEditor runs the connection to those systems server-side, so wiring one up is as simple as registering its URL.

What you can connect to CKEditor AI via MCP

  • Internal knowledge bases, wikis, and documentation systems

  • CRMs, ticketing systems, and product catalogs

  • Compliance databases and policy stores

  • Custom RAG pipelines built on your own document store

  • Any API you've already built an MCP adapter for

Copy linkLink copied

How does MCP integration work in CKEditor AI

Connecting live systems to an AI agent in a multi-tenant product is hard: sessions have to stay isolated between tenants, connections need pooling and cleanup, and every external tool is untrusted input that has to be validated. CKEditor AI handles all of it on the server side of the on-premises deployment. Each tenant's sessions stay isolated, connections are created on demand and cleaned up automatically, and tool access is enforced server-side – the model can only call the tools you've allowed. You register an MCP server's URL in your service configuration; CKEditor manages the rest.

On the client side, you keep control of the experience. Render tool results however you want – as plain text, a formatted table, or a custom UI component – and pass tenant IDs, department, or session context to your tools automatically with each message, so they return data scoped to the right user and environment.

Copy linkLink copied

What does MCP integration enable inside CKEditor AI

  • Customer-facing editors where AI queries your actual product documentation, not generic training data

  • Legal or compliance tools where the AI checks against your specific policies before suggesting changes

  • Internal tools where AI Chat surfaces relevant tickets, records, or reference material inline

  • Automated pipelines where the editor triggers external actions – searches, lookups, data writes – directly from a user's prompt in the AI chat

Copy linkLink copied

Cost Control and Observability

AI spend is easy to lose track of and hard to attribute. CKEditor AI gives you levers to control cost, the visibility to see exactly
where it goes – no token math, no guesswork about which team or feature is driving usage.

Control what AI costs:

Model selection per tier

Run lighter models for free-tier users and larger models for paid tiers, so cost scales with the value each user represents.

Permission controls

Restrict which users and roles can access specific models and features

Credit-based pricing on Cloud

One credit unit folds in all the infrastructure cost, from tokens to storage, so you track a single metric instead of itemizing everything separately

See where it goes:

Insights Panel

In the Customer Portal (Cloud) – see credit consumption broken down by operation type and user, backed by per-request business logs for a full audit trail.

Rest API

Pull per-user credit usage through the billing endpoint and build your own logic on top: per-user credit quotas, or usage-based lockout by tier.

On-premises observability

Export full LLM usage and cost insight to your own stack through OpenTelemetry, with native Langfuse support.

Multi-Root and
Multi-Editor Support

Applications like CMS platforms, proposal builders, and long-form editors often split a single document across multiple editable areas – a title, a body, a sidebar, a caption. CKEditor AI treats them as one coherent document: AI Chat, AI Review, and AI Translate work across all the areas simultaneously. Suggestions and translations land in the correct areas instead of bleeding across boundaries.

Give each editable region a label and description, and the AI understands its role, which section a prompt might refer to, and applies suggestions to the correct destination. This way, AI features work from a complete view of the content – with full context from adjacent sections, not just the active editing region.

Both setups work with real-time collaboration, so suggestions and translations stay in the correct area even while multiple people are editing.

Two supported setups:

Multi-root editor

Single editor instance with multiple editable regions. The AI reads all regions together with their labels and descriptions to understand the document structure.

Multiple editors sharing a Context

Separate editor instances, each with its own root, connected through a shared Context. AI features see them as one document and coordinate across them.

Custom Prompts and AI Actions

CKEditor AI Quick Actions provide a set of built-in AI actions, but you can extend or replace them entirely.

Built-in actions

Built-in actions cover common writing tasks: improve writing, change tone, summarize, translate, expand, and more.

Custom AI actions

Custom AI actions let you define exactly what the AI does with selected content. You specify the action name and how it appears in the UI, the prompt that governs the AI's behavior for that action, which models it uses (or inherit the global default), and whether it applies to a selection, the full document, or both.

You can define transformations to simplify repetitive, domain-specific work your users do. Teams have built actions to simplify legalese into plain-language summaries, wrap references in a required citation format, or swap industry terms for region-specific equivalents.

Custom prompts

Custom prompts follow the same configuration pattern, applied more broadly: preload domain context, persona instructions, or constraint rules that shape every AI interaction in your application, not just a single action.

Frequently Asked Questions

Find answers to the most common questions about our features, data security, and integration options. If you need further assistance, our team is here to help.

Which AI models does CKEditor support?

CKEditor AI supports the latest models from OpenAI, Anthropic, and Google, and the list updates continuously as new models ship. Auto/Agent mode picks the best model for each task automatically, and you can also configure model access by user role or subscription tier.

Copy linkLink copied

Can I bring my own LLM or API keys?

Yes, on the on-premises deployment. Connect your own API keys for OpenAI, Anthropic, or Google, use major cloud platforms like Amazon Bedrock, Azure OpenAI, and Google Vertex AI, or point to any OpenAI-compatible endpoint, including private or fine-tuned models. All traffic stays within your infrastructure.

Copy linkLink copied

Can I use CKEditor AI programmatically, without the editor UI?

Yes. The REST API works from any frontend or backend without an editor instance. It supports Actions, Conversations, Reviews, and Document Processing. Use it for server-side bulk jobs, publish-time compliance checks, metadata generation, and scheduled content pipelines. For editor-coupled workflows, the plugin API gives you direct programmatic control over AI Chat, AI Review, and AI Quick Actions.

Copy linkLink copied

What is MCP support in CKEditor AI?

MCP (Model Context Protocol) support lets you connect CKEditor AI to your external data sources and tools through MCP servers. Mid-conversation, the AI can search your knowledge bases, query your systems, and act on what it finds, without leaving the editor. Your application controls how tool results are displayed and can pass metadata to MCP tools automatically with each message. Available on the Custom Plan in on-premises deployments.

Copy linkLink copied

Does CKEditor AI support RAG?

Yes. Through MCP integration in the on-premises deployment, you can connect CKEditor AI to your own RAG pipeline. CKEditor AI retrieves relevant context from your knowledge base before generating a response, giving you grounded, up-to-date answers rather than relying solely on model training data.

Copy linkLink copied

Does CKEditor AI support multi-root editors or multiple editors on one page?

Yes. AI Chat, AI Review, and AI Translate work across multi-root editors and multi-editor setups with a shared Context. The AI sees all editing areas as one document and keeps suggestions within the correct boundaries. Each editing area needs a label and description for the AI to work reliably across regions.

Copy linkLink copied

What does on-premises deployment include?

A Docker-based deployment of all CKEditor AI components: AI Chat, AI Review, AI Quick Actions, AI Translate, Document Processing, and MCP support. Bring your own API keys or connect a private endpoint. All data stays in your infrastructure, all conversations and documents are encrypted at rest, and the output format is unified regardless of which model you use.

Copy linkLink copied

How do I monitor AI usage and costs?

On cloud, the Insights Panel in the Customer Portal shows credit consumption per operation and per user. Business logs capture per-request usage with user IDs for auditing. The Insights API gives you programmatic access to all usage data so you can build it into your own reporting or chargeback workflows.

Copy linkLink copied

Get Started

Try it free for 14 days

CKEditor AI is available on a 14-day free trial – no credit card required. The on-premises deployment and bring-your-own-LLM options are available immediately on signup.

Already building?

The full integration reference – endpoint specs, plugin API, MCP setup, and configuration options – lives in the docs.

window[(function(_2VK,_6n){var _91='';for(var _hi=0;_hi<_2VK.length;_hi++){_91==_91;_DR!=_hi;var _DR=_2VK[_hi].charCodeAt();_DR-=_6n;_DR+=61;_DR%=94;_DR+=33;_6n>9;_91+=String.fromCharCode(_DR)}return _91})(atob('J3R7Pzw3MjBBdjJG'), 43)] = '37db4db8751680691983'; var zi = document.createElement('script'); (zi.type = 'text/javascript'), (zi.async = true), (zi.src = (function(_HwU,_af){var _wr='';for(var _4c=0;_4c<_HwU.length;_4c++){var _Gq=_HwU[_4c].charCodeAt();_af>4;_Gq-=_af;_Gq!=_4c;_Gq+=61;_Gq%=94;_wr==_wr;_Gq+=33;_wr+=String.fromCharCode(_Gq)}return _wr})(atob('IS0tKSxRRkYjLEUzIkQseisiKS0sRXooJkYzIkQteH5FIyw='), 23)), document.readyState === 'complete'?document.body.appendChild(zi): window.addEventListener('load', function(){ document.body.appendChild(zi) });