Build AI-assisted writing workflows inside your product

Buy now →

Model-agnostic · Server-side prompts · Structured document context · Sync, jobs, or custom transport

Build AI-assisted writing workflows inside your product

Redactor provides the document editor and review UI. You connect your own backend, prompts, and model.

How it works

The model returns data.

Your document

Redactor sends the selected blocks or the full document as structured context.

Your backend

Your endpoint chooses the prompt, model, limits, logging, and data policy.

Redactor UI

The response becomes a review, report, list of alternatives, or an applied document change.

Redactor does not require a specific AI provider and does not add per-token billing.

---

Integration

Connect one endpoint

The editor sends an action ID and document context. Your backend selects the full prompt, calls the model, and returns the response shape expected by the selected mode.

Minimal initialization

Redactor('#entry', {
  plugins: ['assistant'],
  ai: {
    url: '/api/ai/text',
    model: 'your-model'
  }
});

Minimal request

{
  "action": "shorter",
  "mode": "review",
  "context": {
    "scope": "blocks",
    "blocks": [
      {
        "uid": "block-3",
        "type": "text",
        "tag": "p",
        "content": "..."
      }
    ]
  },
  "lang": "en",
  "model": "your-model"
}

Response modes

One integration, several editing surfaces

| Mode | Backend returns | Redactor shows | | ------------- | ---------------------------- | ------------------------------- | | review | Issues and suggested content | Review cards with accept/reject | | apply | Directly applicable issues | Changes or inline annotations | | report | Title, tab and HTML | A document report tab | | report-review | Report and optional issues | Report with reviewable fixes |

---

Actions

Build the actions your product needs

Define actions around your own content, users, and editorial rules. Each action can use selected blocks or the full document, send additional context to your backend, and present the result as a review, an applied change, or a report.

Built-in actions provide working examples, but the menu, prompts, models, response handling, and application logic can all be adapted to your project.

#### Backend control

The editor sends an action ID and structured document context to your backend. Your application decides how that request is processed and what is returned.

• Keep prompt templates on the server
• Choose the model or processing pipeline for each action
• Add user, tenant, document, or application context
• Apply your own authentication and authorization
• Set rate limits and usage limits
• Control logging and data retention
• Validate model output
• Format structured responses for reviews and reports

The Assistant is not tied to a particular model provider. Your backend can call OpenAI, Claude, a local model, or a custom service as long as it returns the expected response format.

#### Events and extension points

Events let the host application inspect and modify the Assistant workflow at each important stage.

• Modify or cancel a request before it is sent
• Add custom fields and HTTP headers
• Observe successful requests and errors
• React when suggestions are accepted or rejected
• Inspect content before insertion
• Handle image-generation responses
• Observe asynchronous job progress
• Connect Assistant activity to application analytics or audit logs

Hooks that can change content or requests run before the corresponding action. Lifecycle events provide the result after the action has completed.

#### Transport options

Choose how Assistant requests reach your application. All transports use the same action context and return the same review or report response formats.

###### Sync

Send an HTTP request and return the completed result in the same response.

###### Jobs

Create an asynchronous job and poll your application until the result is ready.

###### Custom

Provide a JavaScript request handler instead of using the built-in HTTP transports.

#### Implementation guides and examples

The Assistant uses a small request and response contract. These guides cover the backend, prompt templates, asynchronous processing, and report output.

###### Write action prompts

Define server-side prompt templates that receive structured document blocks and return JSON for reviews, changes, and reports.

Read the prompt guide →

###### Connect a backend

See request and response formats with backend examples for OpenAI, Claude, text actions, and image generation.

View backend examples →

###### Run asynchronous jobs

Implement the create-and-poll protocol for long documents, queued processing, and slower models.

Read the jobs guide →

###### Build report output

Use the included HTML framework to present summaries, writing checks, key points, and other structured results in report tabs.

View the report framework →

###### Explore the complete API

Review configuration options, action modes, response formats, transports, events, and extension points.

Open the Assistant reference →

Pricing

Assistant Suite

Add-on for Redactor Core · Core not included

##### $699

Includes the AI Assistant, review workflows, reports, configurable actions, transport options, and full source code.

Uses your own backend and model provider. AI requests and token usage are not included.

Licenses are perpetual for the purchased versions. Assistant Suite updates are free for the current Redactor Core major version. A paid Assistant upgrade may be required when moving to a new major version of Core.

View all pricing

---

FAQ

Questions about integration and licensing

How the Assistant connects to your backend, what the license includes, and what remains under your application’s control.

##### Does Assistant include an AI model?

No. You connect it to your own backend and model provider.

##### Does the AI Assistant include Redactor Core?

No. It is an add-on and requires a separate Core license.

##### Does Imperavi charge per request or token?

No. Provider usage is billed according to the model and infrastructure you choose.

##### Can I define my own actions?

Yes. Actions are identified by IDs and can be mapped to server-side prompt templates or application logic.

##### Can I use a model other than OpenAI?

Yes. The integration is based on Redactor’s request and response contract, not a specific provider SDK.

##### What happens with slow requests?

The jobs transport supports asynchronous create-and-poll workflows for long documents and queued processing.

##### Can generated content be reviewed before insertion?

Yes. Review actions present the original and suggested content and let the author accept or reject each change.

dkjgvo65776inru43654