Get Started for FREE

Froala v5.6.0: A Smoother React Setup, an Accessibility Checker and Paint Formatting

Froala v5.6.0 Feature Spotlight

Froala v5.6.0 is about removing friction, both for the developers adding the editor to an app and for the people writing in it. Trying every feature now takes one public key and no sign-up. The React wrapper works smoothly with Vite 8, Next.js and TypeScript. And your users get a built-in Accessibility Checker and Paint Formatting.

Key Takeaways

  • Free trial: add the public trial key and enjoy every feature and plugin free for 30 days. No sign-up form or credit card. How it works
  • For developers: a smoother React setup with Vite 8, Next.js, TypeScript and StrictMode.
  • For your users: a built-in Accessibility Checker (included in every license) and Paint Formatting.
  • Also: email and phone links, draggable popups, a security fix and more bug fixes.
  • Planning ahead: a new browser and framework support policy for Froala 6. Nothing changes in Froala 5.x. Looking Ahead

The New Free Trial: Every Feature, No Sign-Up

Anyone can now evaluate Froala with a public trial key. Pass it in the key option, the same option you use for a paid license key:

JavaScript
new FroalaEditor('#editor', {
  key: 'TRIAL-LICENSE-KEY-FOR-FROALA-NOT-FOR-PRODUCTION-USE'
});

With the trial key, every feature and plugin works. The trial key is for evaluation only. It never licenses a site, so purchase a license and replace the trial key with your license key before going to production.

Once you have a license, your production setup looks like this:

JavaScript
new FroalaEditor('#editor', {
  key: 'YOUR_LICENSE_KEY',
  attribution: false // remove the "Powered by Froala" text
});

A short notice replaces the red banner. In previous versions, an editor without a valid license key showed a red banner. Now it shows a one-line notice next to the “Powered by Froala” text, and the same message is printed once per page in the browser console. The notice tells you your key’s status (missing, trial, invalid or expired) and links to what to do next.

Froala old red banner

 

Froala new activation

Good to know

  • Localhost now works like your live site. With no key or the trial key, local hosts (such as localhost) now show the same notice as a public website.
  • One key covers a domain and all its subdomains.
  • 15-day renewal grace period. An annual (term) key keeps a clean editor for 15 days after it expires. After that, the expired notice shows on every site, including localhost.

Learn more in the Activation docs.

What’s New in v5.6.0

For Developers

Changes that make Froala easier to set up and build with.

React Wrapper Upgrade: A Smoother Setup with Vite 8, Next.js, TypeScript and StrictMode

What it is: A round of fixes and documentation updates for the React wrapper (react-froala-wysiwyg), so it works the way modern React apps expect.

Why it matters: A fresh Vite app now works on the first try, Next.js has a tested setup, your handlers run when you expect them to, and TypeScript catches mistakes before they ship. That means less time debugging the setup and more time building your product.

At a glance:

  • Vite 8: the standard default import works, so no more blank page.
  • StrictMode: your initialized handler no longer runs three times.
  • onModelChange: fires only when the content changes, not when the editor loads.
  • TypeScript: props and option values are type-checked, and the config types are exported.
  • Refs: initialize() and destroy() now work on a ref instead of throwing.
  • Next.js: a tested App Router setup in the README.
  • Docs: a rewritten README that also documents how config and undo history behave.

How to use it: Update to react-froala-wysiwyg@5.6.0 (see the upgrade steps below). Here’s what each change means for your code.

Vite 8 apps no longer show a blank page. In a new Vite 8 app, the README quick start rendered a blank page, with “Element type is invalid … got: object” in development (React error #130 in a production build). Vite 8 loads older CommonJS packages differently, so the default import returned an object instead of the component. The package now exports the component itself, so the standard import just works:

JSX
import FroalaEditorComponent from 'react-froala-wysiwyg';

If you added code to unwrap .default as a workaround, you can remove it. Apps on Vite 7 keep working as before.

initialized no longer runs three times. React StrictMode (a development-only check) mounts each component, unmounts it and mounts it again. The wrapper kept old handlers around when the editor was destroyed, so your initialized handler ran three times in development. It now runs once for each editor that’s created: twice in StrictMode development, because React creates the editor twice on purpose, and once in production. The same fix applies when you call destroy() and then initialize() yourself.

onModelChange fires only on real changes. Before, it fired once on mount with the same value you passed in model. Now it fires only when the editor’s HTML differs from the last model value, so autosave, “unsaved changes” flags and analytics no longer trigger on load. Typing, paste, undo (even back to the starting value) and redo still fire it. This applies to the main editor component; the image, link, button and input components behave as before.

Real TypeScript types. Before, config and onModelChange were loosely typed, so in strict mode onModelChange={(m) => setModel(m)} failed with an implicit-any error, while a wrong value such as toolbarSticky: 'yes' compiled. Now config is typed from the editor’s own options plus the wrapper’s (immediateReactModelUpdate, reactIgnoreAttrs), onModelChange receives a string, and getEditor() returns the editor instance or null. FroalaEditorConfig, FroalaEditorProps and ManualController are exported:

TSX
import { useState } from 'react';
import FroalaEditorComponent from 'react-froala-wysiwyg';
import type { FroalaEditorConfig } from 'react-froala-wysiwyg';

const config: FroalaEditorConfig = {
  placeholderText: 'Start writing',
  toolbarSticky: true
};

export default function Editor() {
  const [model, setModel] = useState('');
  return <FroalaEditorComponent model={model} onModelChange={setModel} config={config} />;
}

Option values are checked, but a misspelled option name still compiles, so keep an eye on spelling.

Ref methods that work. The types used to declare initialize() and destroy() on the component, but the methods didn’t exist, so ref.current.destroy() compiled and then threw at runtime. Both are now real methods, next to getEditor():

JSX
import { useRef } from 'react';
import FroalaEditorComponent from 'react-froala-wysiwyg';

export default function EditorWithRef() {
  const editorRef = useRef(null); // TypeScript: useRef<FroalaEditorComponent>(null)

  return (
    <>
      <button type="button" onClick={() => editorRef.current?.destroy()}>Remove editor</button>
      <button type="button" onClick={() => editorRef.current?.initialize()}>Create it again</button>
      <FroalaEditorComponent ref={editorRef} />
    </>
  );
}

Two behaviors, now documented. The config prop is read once, when the editor is created, so give the component a new key to apply new options. And a model change from outside the editor clears the undo history unless you pass skipReset. Passing back the value you got from onModelChange (the usual controlled pattern) never resets it. The README shows both with examples.

A tested Next.js setup. Next.js renders pages on the server first (server-side rendering, or SSR), and importing react-froala-wysiwyg there fails, even from a 'use client' file, which breaks next build. The README now includes a tested App Router pattern: put the editor in its own client component and load it with next/dynamic and ssr: false. For other SSR frameworks, it shows a React.lazy setup.

The React README was rewritten to match, with fixed examples and new sections for TypeScript, SSR, StrictMode, refs and undo history.

For Your Users

New tools that help the people writing in your app create cleaner, more consistent and more accessible content.

Accessibility Checker: Find and Fix WCAG Issues as You Write

What it is: A new Accessibility Checker plugin that checks the content against WCAG (Web Content Accessibility Guidelines, the international standard for accessible web content) and helps fix problems on the spot.

Accessibility Checker Plugin

Click the Accessibility Checker button (the person icon in the More Misc group) and the content is scanned. A popup then shows each finding one at a time: what’s wrong, why it matters, and a link to learn more. The problem element is outlined in the content, and you can step through findings with Previous and Next, Ignore one for the session, Rescan, or click Fix to repair it in place. The toolbar button shows a badge with the number of findings, and a tick when everything passes.

What it checks:

Area What it catches One-click fix?
Headings Text that looks like a heading but isn’t one; skipped heading levels (such as h2 straight to h4) Yes
Lists Lists typed by hand with numbers or dashes instead of a real list No
Links Two links next to each other that go to the same address No
Color contrast Text that’s hard to read against its background No
Duplicate IDs The same id used more than once Yes
Images Missing alt text, alt text that’s a file name (like IMG_0042.jpg), alt text over 125 characters, mixed signals Yes
Tables Missing caption, missing header cells, unclear header scope, tables with no data Mostly

Findings are written for the person editing, not for a developer, and every message is translated with the rest of the editor’s strings. Some results, like text over a background image, can’t be judged automatically; these show as Needs review and explain what to check by eye.

The image alt text dialog also gains a Mark as decorative checkbox, so purely decorative images can be skipped by screen readers.

Why it matters: Your editor’s UI may already be accessible, but the content people write often isn’t. Schools, government bodies and large companies are often legally required to publish accessible content, and catching issues while writing is far cheaper than fixing them after publishing. The checker is included in every license.

How to use it: It’s on by default. Pick your conformance level ('A', 'AA' or 'AAA', default 'AA') and fine-tune the built-in rules:

JavaScript
new FroalaEditor('#editor', {
  accessibilityCheckerLevel: 'AA',
  accessibilityCheckerRules: [
    { id: 'I4', options: { max: 80 } }, // shorter alt text limit
    { id: 'D3', enabled: false }        // switch a rule off
  ]
});

You can also run a scan from code, for example to warn users before they publish:

JavaScript
const editor = new FroalaEditor('#editor', {}, function () {
  document.querySelector('#publish').addEventListener('click', function () {
    const errors = editor.accessibilityChecker.check().filter(function (issue) {
      return issue.severity === 'error';
    });
    if (errors.length) {
      editor.accessibilityChecker.showPopup();
    }
  });
});

Have your own content guidelines? Add a custom rule for every editor on the page:

JavaScript
FroalaEditor.RegisterA11yRule({
  id: 'ACME1',
  title: 'Vague link text',
  message: 'Link text should say where the link goes, not just "click here".',
  selector: 'a',
  test: function (link) {
    return !/^click here$/i.test(link.textContent.trim());
  }
});

Other useful options include accessibilityCheckerAutoCheck (rescan automatically after edits), accessibilityCheckerHelpUrl (point “Learn more” links to your own guidelines) and accessibilityCheckerAllowDecorativeImages. Events such as accessibilityChecker.checked and accessibilityChecker.repaired let you log or filter findings. See the API docs for the full list.

Paint Formatting: Copy a Style, Click to Apply

Froala Paint Format feature

What it is: Paint Formatting copies the look of one piece of text and “paints” it onto another, like the format painter in Word or Google Docs. Your users:

  1. Put the cursor in formatted text.
  2. Click the Paint Formatting button.
  3. Click a word, or drag across some text. Done.

It copies bold, italic, underline, strikethrough, subscript, superscript, font family, font size, text color, highlight color, and styles or classes added with the Inline Style and Inline Class plugins. It never copies or changes the text itself, links, images, tables, or paragraph settings such as headings, alignment, indentation and line height.

A few details your users will appreciate:

  • Continuous painting: the arrow next to the button opens a switch that keeps paint mode on, so users can style many places in a row. Click the button again or press Esc to stop.
  • Keyboard shortcut: Ctrl+Alt+C turns paint mode on (Control+Option+C on macOS). Press it again with text selected to paint that selection.
  • One Undo reverts a whole paint.
  • Clean results: painting replaces the target’s inline formatting instead of mixing it, and painting from plain text clears it.
  • Track Changes aware: with Track Changes on, painted formatting is recorded as suggestions.

Why it matters: Re-applying the same font, size and color by hand is slow and easy to get wrong. Paint Formatting turns it into two clicks, keeps long documents consistent, and is included in every license.

How to use it: The Paint Format plugin is on by default and the button sits right before Clear Formatting in the default toolbar. To place it yourself, or to keep paint mode on after each paint by default:

JavaScript
new FroalaEditor('#editor', {
  toolbarButtons: [['bold', 'italic', 'underline', 'paintFormat', 'clearFormatting']],
  paintFormatContinuous: true
});

Need to react to painting in your app? Listen to the new events:

JavaScript
new FroalaEditor('#editor', {
  events: {
    'paintFormat.applied': function (format) {
      console.log('Painted', format.tags, format.styles);
    }
  }
});

Developers also get paintFormat.start, paintFormat.end events and methods such as paintFormat.copy(), apply(), start(), stop(), isActive() and setContinuous() to build custom flows.

Known limit: selected table cells can’t be painted in this version. If the selection is a range of cells, nothing changes and the editor announces “Can’t paint selected cells”.

 

Improvements and Enhancements

Email and Phone Links popup

What it is: The Insert Link popup can now create email (mailto:) and phone (tel:) links, not just web links. When enabled, the popup shows three tabs: URL, Email and Phone.

  • Email tab: To (one address, or several separated by commas), plus optional Subject, Body and link text. For example: mailto:team@example.com?subject=Hello&body=Thanks
  • Phone tab: a number plus optional link text. The link keeps only the digits and a leading +, so +1 (415) 555-2671 becomes tel:+14155552671.

Invalid addresses or numbers show a short message under the field, and the link isn’t inserted until it’s fixed. Editing an existing email or phone link reopens the right tab with the fields filled in.

Why it matters: Contact pages, newsletters and support content are full of “email us” and “call us” links. Your users no longer need to know mailto: syntax to create them correctly.

How to use it: The tabs are off by default, so existing popups look the same. Add linkByEmail and/or linkByPhone to linkInsertButtons. You can also set the phone format your users should follow, for example UK mobile numbers:

JavaScript
new FroalaEditor('#editor', {
  linkInsertButtons: ['linkBack', '|', 'linkList', '|', 'linkByURL', 'linkByEmail', 'linkByPhone'],
  linkPhonePattern: /^\+44 ?\d{4} ?\d{6}$/,
  linkPhoneExample: '+44 7911 123456',
  linkPhoneErrorMessage: 'Enter a UK mobile number, like +44 7911 123456.'
});

By default, linkPhonePattern accepts 5 to 15 digits with an optional leading +, which suits most countries. To switch tabs from code, use the new editor.link.showLayer('email') method.

Draggable Popups

Set the new popupDraggable option to let users drag popups (link, table, image and the rest) by a handle at the top and place them anywhere in the visible window. It’s handy when the editor sits in a short area, such as fullscreen inside an iframe, where a popup has no room to open next to its anchor.

JavaScript
new FroalaEditor('#editor', {
  popupDraggable: true
});

It works with a mouse, touch, and the keyboard: the handle is labeled “Move popup”, and the arrow keys move the popup 10 px at a time. A popup can’t be dragged out of view, and it opens next to its anchor again the next time. The option is off by default.


Bug Fixes

Security

  • Word Export plugin hardened. We fixed potential DOM-based XSS (cross-site scripting) vulnerabilities in the Word Export plugin. If you use it, we recommend upgrading.

Angular

  • Reactive Forms stay in sync after a reset. After resetting a form control, making the same edit again now updates the control’s value right away, instead of needing a second change.
  • Popups now show above Angular Material v21 dialogs. Dialogs that use the browser’s native Popover API no longer hide Froala’s image, link and table popups behind them.

Pasting and editing

  • Word paste keeps your spacing. Gaps made with spaces, non-breaking spaces or tabs (for example, between two fields on the same line) are no longer collapsed when pasting from desktop Word or Word on the web.
  • Clear Formatting keeps comments. Clearing the formatting of commented text no longer removes the comments.

This release includes more fixes than we’ve listed here. See the full changelog for every change in v5.6.0.


Looking Ahead: Support Policy for Froala 6

Our new rules, starting with Froala v6.0.0: Froala’s support for any version ends no later than its maker’s. “Supported” means we actively test the editor there and fix bugs reported for it. Nothing changes in Froala 5.x, including every current integration.

  • Browsers: the current and previous major version of Chrome, Firefox, Safari, Opera and Edge. Firefox ESR and mobile WebViews join the list, and iOS and Android move to their current and previous major versions. Internet Explorer 11 will no longer be supported. Pre-release builds (beta, dev or canary) are not supported.
  • Frameworks and server SDKs: every Active and LTS framework version, and every runtime version still getting security fixes. Where a project has no published support policy, we support its latest two major versions. Froala 6 keeps supporting React, Angular, Vue, Svelte, Ruby on Rails, Django, WordPress and .NET (NuGet), plus server SDKs for PHP, Node.js, Python, .NET Framework, Java and Ruby, all updated to the latest versions of their frameworks and languages.
  • Retiring in Froala 6: Aurelia, AngularJS (Angular 1), CakePHP, Craft CMS 3, Ember, Knockout, Laravel Nova, Meteor, Symfony and Yii 2. They keep working with Froala 5.x, but won’t be included or updated in Froala 6.

See the full details on the new Browser and Framework Support page.


Upgrading to Froala v5.6.0

Upgrade notes for React projects: no changes to the documented API. If you use TypeScript or load the package with require(), check these two things:

1. The built files now export the component itself. If you load react-froala-wysiwyg with require() or as a browser global, the module is now the component class (it no longer carries an __esModule flag). require('react-froala-wysiwyg').default still works, so most apps need no change. Only code that inspected the old export object is affected.

2. TypeScript props are stricter. Code that was already wrong may now fail to compile, for example passing tag to the special-tag components (FroalaEditorA, FroalaEditorButton, FroalaEditorImg, FroalaEditorInput), passing config to FroalaEditorView, or passing something that isn’t a function to onModelChange, or a wrong option value such as toolbarSticky: 'yes'. Fix the flagged props. The old MyComponentProps type still works as a deprecated alias.

Behavior changes to review

  • React: onModelChange no longer fires on mount, or when you set a model whose HTML comes back unchanged. If you relied on that first call, read the initial value from your own state instead.
  • Angular: form writes (reset(), patchValue, [(froalaModel)]) now run your own contentChanged handler. The form itself doesn’t treat this as a user edit.
  • Licensing: with no key or the trial key, localhost now shows the license notice. Licensed keys are unaffected.
  • Default toolbar: if you use the default toolbar, users will see two new buttons: Paint Formatting (before Clear Formatting) and Accessibility Checker (More Misc group). To hide them, set your own toolbarButtons or use pluginsDisabled: ['paintFormat', 'accessibilityChecker'].
  • Custom helpSets: the default shortcuts dialog now includes Paint Formatting. If you pass your own helpSets, add the entry yourself:
    JavaScript
    helpSets: [
      {
        title: 'Paint Formatting',
        commands: [{ val: 'CtrlAltC', desc: 'Copy formatting, or paint it onto the selection' }]
      }
    ]
    
  • Custom htmlAllowedAttrs: editors with the Accessibility Checker enabled now keep role and aria-* attributes, so decorative images stay decorative. If you set htmlAllowedAttrs yourself, add 'role' and 'aria-.*' to your list to keep them.

Step-by-step

1. Update the packages. Update the core editor and your framework wrapper together:

Terminal
# Core editor
npm install froala-editor@5.6.0

# React
npm install froala-editor@5.6.0 react-froala-wysiwyg@5.6.0

# Angular
npm install froala-editor@5.6.0 angular-froala-wysiwyg@5.6.0

Using another integration? Update its package to the matching version.

2. Or update your CDN links:

HTML
<link href="https://cdn.jsdelivr.net/npm/froala-editor@5.6.0/css/froala_editor.pkgd.min.css" rel="stylesheet" type="text/css" />
<script type="text/javascript" src="https://cdn.jsdelivr.net/npm/froala-editor@5.6.0/js/froala_editor.pkgd.min.js"></script>

3. Loading plugins one by one? The packaged files (froala_editor.pkgd) already include the new plugins. If you load plugin files individually, add the Paint Formatting plugin files and the Accessibility Checker files (js/plugins/accessibility_checker.min.js and css/plugins/accessibility_checker.css).

4. React on Vite 8? Remove any workaround you added to unwrap the default import.

5. Test your main flows: loading and saving content, the toolbar buttons you use, paste from Word, and uploads.


Try Froala v5.6.0 Today

Add Froala to your Vite or Next.js app with less setup, run the Accessibility Checker on your content, and paint a style across a document in two clicks. Everything works with the public trial key, so you can start right away.

Found a bug in a supported browser? Report it on our Froala GitHub issues page.

Posted on November 18, 2026

Mostafa Yousef

Senior web developer with a profound knowledge of the Javascript and PHP ecosystem. Familiar with several JS tools, frameworks, and libraries. Experienced in developing interactive websites and applications.

No comment yet, add your voice below!


Add a Comment

Your email address will not be published. Required fields are marked *