This code snippet is designed to function effectively in version 4.3.12 of tinyMCE, offering the ability to capture paste events:

UPDATE: The bugs have been rectified and additional functionality has been implemented to show a character counter below the editor. It should be noted that this approach may not be optimal since it relies somewhat on the current HTML structure of tinyMCE, specifically requiring the editor div to precede the hidden textarea.

Notably, this iteration only calculates the length of text content while disregarding the length of HTML tags. To include HTML tag length in the count, substitute all instances of "innerText" with "innerHTML".

tinymce.init({
    max_chars: 1000, // maximum character limit
    setup: function (ed) {
        var allowedKeys = [8, 37, 38, 39, 40, 46]; // backspace, delete, and arrow keys
        ed.on('keydown', function (e) {
            if (allowedKeys.indexOf(e.keyCode) != -1) return true;
            if (tinymce_getContentLength() + 1 > this.settings.max_chars) {
                e.preventDefault();
                e.stopPropagation();
                return false;
            }
            return true;
        });
        ed.on('keyup', function (e) {
            tinymce_updateCharCounter(this, tinymce_getContentLength());
        });
    },
    init_instance_callback: function () { // initialize counter div
        $('#' + this.id).prev().append('<div class="char_count" style="text-align:right"></div>');
        tinymce_updateCharCounter(this, tinymce_getContentLength());
    },
    paste_preprocess: function (plugin, args) {
        var editor = tinymce.get(tinymce.activeEditor.id);
        var len = editor.contentDocument.body.innerText.length;
        var text = $(args.content).text();
        if (len + text.length > editor.settings.max_chars) {
            alert('Pasting this exceeds the maximum allowed number of ' + editor.settings.max_chars + ' characters.');
            args.content = '';
        } else {
            tinymce_updateCharCounter(editor, len + text.length);
        }
    }
});

function tinymce_updateCharCounter(el, len) {
    $('#' + el.id).prev().find('.char_count').text(len + '/' + el.settings.max_chars);
}

function tinymce_getContentLength() {
    return tinymce.get(tinymce.activeEditor.id).contentDocument.body.innerText.length;
}

Source: How can I prevent tinyMCE's paste event?

TinyMCE 4+
+
jQuery

<textarea id="description_edit" name="description_edit"><?=htmlspecialchars($this->company->description);?></textarea>

<div><span>Characters remaining:</span> <span id="chars_left"></span></div>


<script type="text/javascript" src="/js/tinymce/tinymce.min.js"></script>
<script>
    var max_chars = 200; //maximum characters allowed
    var max_for_html = 300; //maximum characters for html tags
    var allowed_keys = [8, 13, 16, 17, 18, 20, 33, 34, 35, 36, 37, 38, 39, 40, 46];
    var chars_without_html = 0;

    function checkChars() {
        if (chars_without_html > (max_chars - 25)) {
            $('#chars_left').css('color', 'red');
        } else {
            $('#chars_left').css('color', 'gray');
        }
    }

    $(function () {
        tinymce.init({
            selector: "#description_edit",
            theme: "modern",
            width: 320,
            height: 130,
            plugins: [
                "advlist autolink lists charmap print preview hr anchor pagebreak",
                "searchreplace visualblocks visualchars code insertdatetime media nonbreaking",
                "save table contextmenu directionality paste textcolor"
            ],
            image_advtab: true,
            language: 'en',
            menubar: false,
            statusbar: false,

            setup: function (ed) {
                ed.on("KeyDown", function (ed, evt) {
                    chars_without_html = $.trim(tinyMCE.activeEditor.getContent().replace(/(<([^>]+)>)/ig, "")).length;
                    chars_with_html = tinyMCE.activeEditor.getContent().length;
                    var key = ed.keyCode;

                    $('#chars_left').html(max_chars - chars_without_html);

                    if (allowed_keys.indexOf(key) != -1) {
                        checkChars();
                        return;
                    }

                    if (chars_with_html > (max_chars + max_for_html)) {
                        ed.stopPropagation();
                        ed.preventDefault();
                    } else if (chars_without_html > max_chars - 1 && key != 8 && key != 46) {
                        alert('You have reached the character limit!');
                        ed.stopPropagation();
                        ed.preventDefault();
                    }
                    checkChars();
                });
            },

            toolbar: "bold italic underline | alignleft aligncenter alignright alignjustify | forecolor backcolor | bullist numlist | charmap",
            style_formats: [
                {title: 'Bold text', inline: 'b'},
                {title: 'Red text', inline: 'span', styles: {color: '#ff0000'}},
                {title: 'Red header', block: 'h1', styles: {color: '#ff0000'}},
                {title: 'Example 1', inline: 'span', classes: 'example1'},
                {title: 'Example 2', inline: 'span', classes: 'example2'},
                {title: 'Table styles'},
                {title: 'Table row 1', selector: 'tr', classes: 'tablerow1'}
            ]
        });

        chars_without_html = $.trim($("#description_edit").text().replace(/(<([^>]+)>)/ig, "")).length;
        $('#chars_left').html(max_chars - chars_without_html);
        checkChars();
    });
</script>

I found some great answers above, but I have a new suggestion for setting the max_chars attribute directly on the textarea element itself.

initiate : function(editor) {
        editor.onKeyPress.add(function(editor, event) {
            //if ( $(editor.getBody()).text().length+1 > editor.getParam('max_chars')){
            if ( $(editor.getBody()).text().length+1 > $(tinyMCE.get(tinyMCE.activeEditor.id).getElement()).attr('max_chars')){
                event.preventDefault();
                event.stopPropagation();
                return false;
            }
        });
    } 

Supporting backspace and delete keys for providing assistance. This is my version:

char_limit : 2000,
indicator_element : ".limitSpan",

initialize : function(editor) {  
    character_count = 0;
    
    countCharacters = function (editor, event) {
        content = editor.getContent().replace(/<[^>]*>/g, '').replace(/\s+/g, ' ');
        content = content.replace(/^\s\s*/, '').replace(/\s\s*$/, '');
        this.character_count = editor.getParam('char_limit') - content.length;

        $(editor.getParam('indicator_element')).text(this.character_count + " (out of " + editor.getParam('char_limit') + ") char(s) remaining.");
    };

    editor.onKeyUp.add(countCharacters);

    editor.onKeyDown.add(function(editor, event) {
        if (this.character_count <= 0 && event.keyCode != 8 && event.keyCode != 46) {
            tinymce.dom.Event.cancel(event);
        }
    });

This approach proved to be effective in resolving my issue.

I took the provided code from @needfulthing and made necessary corrections and enhancements.

function updateTinymceEditor(){

        tinymce.init({
            selector: '.richtext-editable',
            plugins: ['paste'],

            max_chars: 50000, // maximum character limit

            setup: function (ed) {                              
                var allowedKeys = [8, 13, 16, 17, 18, 20, 33, 34, 35, 36, 37, 38, 39, 40, 46];
                ed.on('keydown', function (e) {
                    if (allowedKeys.indexOf(e.keyCode) != -1) return true;
                    if (tinymce_getContentLength() + 1 > this.settings.max_chars) {
                        e.preventDefault();
                        e.stopPropagation();
                        return false;
                    }
                    return true;
                });
                ed.on('keyup', function (e) {
                    updateCharacterCount(this, getContentLength());
                });                             
            },

            init_instance_callback: function () { // initialize counter div
                $('#' + this.id).prev().append('<div class="char_count" style="text-align:right"></div>');
                updateCharacterCount(this, getContentLength());
            },

            paste_preprocess: function (plugin, args) {                             
                var editor = tinymce.get(tinymce.activeEditor.id);
                var len = editor.contentDocument.body.innerText.length;                             
                if (len + args.content.length > editor.settings.max_chars) {
                    alert('Pasting this exceeds the maximum allowed number of ' + editor.settings.max_chars + ' characters for the input.');
                    args.content = '';
                }                                   
                updateCharacterCount(editor, len + args.content.length);                               
            }

        });

        function updateCharacterCount(el, len) {
            $('#' + el.id).prev().find('.char_count').text(len + '/' + el.settings.max_chars);
        }

        function getContentLength() {
            return tinymce.get(tinymce.activeEditor.id).contentDocument.body.innerText.length;
        }

}

To enhance the example provided by Vladimir Miroshnichenko, I made some modifications to accurately count characters, especially in languages with accented characters.

In addition to using the Javascript SpellChecker instead of tinyMCE's outdated version (4.1), I included a button in the toolbar to trigger $Spelling.SpellCheckInWindow('editors'). This feature works seamlessly with tinyMCE 4.1.7.

I also integrated a word count feature for those who prefer setting alarms based on word count rather than characters.

<textarea id="paragraph1" name="description_edit"><?=htmlspecialchars($this->company->description);?></textarea>

<div><span>Characters left:</span> <span id="chars_left"></span></div>

<script type="text/javascript" src="tinymce/tinymce.min.js"></script>
<script type="text/javascript" src="JavaScriptSpellCheck/include.js"></script>

<script>
var max_chars    = 300; //max characters
var max_for_html = 1000; //max characters for html tags
var allowed_keys = [8, 13, 16, 17, 18, 20, 33, 34, 35,36, 37, 38, 39, 40, 46];
var chars_without_html = 0;

function alarmChars(){
    if(chars_without_html > (max_chars - 25)){
        $('#chars_left').css('color','red');
    }else{
        $('#chars_left').css('color','gray');
    }
}        

$(function() {
    tinymce.init({
        selector: "textarea#paragraph1",
        theme: "modern",
        plugins: [
            "advlist autolink lists charmap preview hr anchor pagebreak",
            "visualblocks visualchars insertdatetime nonbreaking",
            "directionality paste textcolor"
        ],
        menubar:false,
        statusbar:false,

        toolbar: "bold italic underline | alignleft aligncenter alignright alignjustify | forecolor backcolor | bullist numlist | charmap | preview | Spellcheck", 

        setup : function(ed) {
            ed.addButton('Spellcheck', {
                title : 'Spellcheck',
                image : '/img/dict.png',
                onclick : function() {
                    // Add you own code to execute something on click
                    $Spelling.SpellCheckInWindow('editors');
                }
            });

            ed.on("KeyDown", function(ed,evt) {
                    whtml = tinyMCE.activeEditor.getContent();

                    without_html = whtml.replace(/(<([^>]+)>)/ig,"");
                    without_html = without_html.replace(/&([A-za- z])(?:acute|cedil|caron|circ|grave|orn|ring|slash|th|tilde|uml);/ig,'$1');
                    without_html = without_html.replace(/&hellip;/ig,'...');
                    without_html = without_html.replace(/&rsquo;/ig,'\'');
                    without_html = $.trim(without_html.replace(/&([A-za-z]{2})(?:lig);/ig,'$1'));

                    chars_without_html = without_html.length;
                    chars_with_html    = whtml.length;

                    wordscount = without_html.split(/[ ]+/).length;  // Just to get the wordcount, in case...

                    var key = ed.keyCode;

                    $('#chars_left').html(max_chars - chars_without_html);

                    if(allowed_keys.indexOf(key) != -1){
                        alarmChars();
                        return;                                                         
                    }

                    if (chars_with_html > (max_chars + max_for_html)){
                        ed.stopPropagation();
                        ed.preventDefault();
                    }else if (chars_without_html > max_chars-1 && key != 8 && key != 46){
                        alert('Characters limit!');
                        ed.stopPropagation();
                        ed.preventDefault();
                    }
                    alarmChars();                                                   
                }
            );
        },
    });

    whtml = $("#paragraph1").text();

    without_html = whtml.replace(/(<([^>]+)>)/ig,"");
    without_html = without_html.replace(/&([A-za-z])(?:acute|cedil|caron|circ|grave|orn|ring|slash|th|tilde|uml);/ig,'$1');
    without_html = without_html.replace(/&hellip;/ig,'...');
    without_html = without_html.replace(/&rsquo;/ig,'\'');
    without_html = $.trim(without_html.replace(/&([A-za-z]{2})(?:lig);/ig,'$1'));

    chars_without_html = without_html.length;

    $('#chars_left').html(max_chars - chars_without_html);
    alarmChars();                                           
});    

I believe these updates will be beneficial as the tinyMCE team appears unwilling to address this issue adequately.

    // Obtain text statistics for a specified editor using its id
function calculateStatistics(id) {
    var body = tinymce.get(id).getBody(), text = tinymce.trim(body.innerText || body.textContent);

    return {
        characters: text.length,
        words: text.split(/[\w\u2019\'-]+/).length
    };
} 





function sendFormData() {
        // Verify if user input is less than 10 characters
        if (calculateStatistics('content').characters < 10) {
            alert("Please enter at least 1000 characters.");
            return;
        }

        // Check if the user has entered less than 1 word
        if (calculateStatistics('content').words < 1) {
            alert("You need to enter at least one word.");
            return;
        }

        // Submit the form
        document.forms[0].submit();
    }

Trust this information proves useful

If you're looking to limit the character count in TinyMCE, there isn't a built-in setting for max_chars. However, you can create your own implementation as shown below:

tinyMCE.init({
   ...
   max_chars : "10",
   setup : function(ed) {
      ed.onKeyDown.add(function(ed, evt) {

        if ( $(ed.getBody()).text().length > ed.getParam('max_char')){
          e.preventDefault();
          e.stopPropagation();
          return false;
        } 

      });
   }
});

After trying out the solution, I noticed a minor bug. If you are experiencing an incorrect character count, it could be due to using

ed.on("KeyDown")

To resolve this issue, simply change it to

ed.on("KeyUp") 

This adjustment should fix the problem. I haven't had the chance to test it with ('Change'), but it might work as well!

It seems that tinyMCE does not offer a built-in feature to limit the number of characters a user can input. To achieve this, you would need to use a specific plugin or implement custom logic for character restriction. The code below illustrates an issue I encountered with this functionality, but it is functioning correctly.

This code snippet is designed for a textarea identified by the ID summary, along with another paragraph element with the ID character_count that displays the character count. Users are prevented from exceeding the specified character limit (max) and can only use the backspace key once reaching the limit. You have the flexibility to configure other keys based on their ASCII values within the given condition.

tinymce.init({
  selector: '#summary',  // adjust as needed in your HTML
  auto_focus: 'element1',
  statusbar: false,
  toolbar: 'undo redo | styleselect | bold italic underline | formatselect | aligncenter | fontselect',
  setup: function (ed) {
            ed.on('KeyDown', function (e) { 
                var max = 150;
                var count = CountCharacters();
                if (count >= max) {
                        if(e.keyCode != 8 && e.keyCode != 46)
                          tinymce.dom.Event.cancel(e);
                          document.getElementById("character_count").innerHTML = "Maximum allowed characters: 150";

                } else {
                    document.getElementById("character_count").innerHTML = "Characters: " + count;
                 }
            });

        }
 });

 function CountCharacters() {
    var body = tinymce.get("summary").getBody();
    var content = tinymce.trim(body.innerText || body.textContent);
    return content.length;
};

The method outlined below has been effective for me: 1 - Ensure that the html code of the textarea contains both the value of maxlength and the id of the textarea.
2 - In the script section, include the following code. If desired, uncomment the alert() line to display a custom message.

<script type="text/javascript>
  tinymce.init ({
    ...
    ...
      setup: function(ed) {
        var maxLength = parseInt($("#" + (ed.id)).attr("maxlength"));
        var count = 0;
        ed.on("keydown", function(e) {
          count++;
          if (count > maxLength) {
            // alert("You have reached the character limit");
            e.stopPropagation();
            return false;
          }
        });
     },

<textarea type="text" id="test" name="test" maxlength="10"></textarea>

Adapting to the changes introduced by the new version of tinyMCE4X.

    tinymce.init({
    charLimit : 10, // initially set to 10 but can be adjusted later
    setup: function(editor) {
        editor.on('change', function(e) {
            //declare local variables
            var maxChars, contentLength;
            //setting the maximum character limit
            maxChars = this.settings.charLimit;
            //getting the length of the current editor's content
            contentLength = this.getContent().length;
            if (contentLength > maxChars) {
                alert('Exceeded character limit');
            }
        });
    }
    });

Are you in search of a quick and easy solution? I have just the thing for you. Check out this simple solution that may not be flawless, but gets the job done

let max_char = 3;
    tinymce.init({
        selector: '#description',
        // custom settings for tiny mce
        toolbar: ' undo redo | bold italic | formatselect',
        setup : function(ed) {
           // crucial section
           ed.on("keypress", function(event){
                // retrieve content from tinymce and remove any tags
                // as tags get added by tinymce while typing
                // removing tags gives the actual input length (what the user sees)
                let content =  tinymce.activeEditor.getContent().replace(/(<([^>]+)>)/ig,"");
                // now compare that length to desired length.
                // if it's equal or longer, return false to ignore last input
                if(content.length >= max_length){
                    return false;
                }
            });
        }

    });

Implementing TinyMCE with AngularJS

If you want to restrict the maximum number of characters on the frontend, you can do so using the ng-maxlength directive available in AngularJS.

Parameter: ngMaxlength
Type: number
Details: This sets a maxlength validation error key if the entered value exceeds the specified maximum length.

Keep in mind that this directive doesn't only count visible text characters; it includes all content within the <textarea>, including HTML tags and scripts.

To begin, make sure to include AngularJS, the TinyMCE 4 distribution, and the AngularUI wrapper for TinyMCE.

HTML:

<form name="form" action="#">
    <textarea ng-model="myMCEContent" ui-tinymce ng-maxlength="200" name="body"></textarea>
    <span ng-show="form.body.$error.maxlength" class="error">Reached limit!/span>
</form>

JavaScript:

angular.module('myApp', ['ui.tinymce'])
.config(['$sceProvider', function($sceProvider) {
    // Disable Strict Contextual Escaping
    $sceProvider.enabled(false);
}])
.constant('uiTinymceConfig', {/*...*/})
.controller('myCtrl', ['$scope', function($scope) {
    // ...
}]);

jsFiddle

Important Note!

Prior to implementing this solution, be sure to thoroughly read the manual to understand the implications of disabling SCE in AngularJS: $sce service.

Here's a simple solution:

let contentLength = tinyMCE.activeEditor.getContent({format: 'text'}).length; // Get the length of the current editor content

if (contentLength > 1499) {
    e.preventDefault();
    e.stopPropagation();
    return false;
} // I have set my limit to 1500 in this project.

To disable pasting:

editor.on('paste', function(e){
    contentLength = tinyMCE.activeEditor.getContent({format: 'text'}).length;
    let data = e.clipboardData.getData('Text');
    if (data.length > (1500 - contentLength)) {
        return false;
    } else {
        return true;
    }
});