diff --git a/Doc/library/xml.etree.elementtree.rst b/Doc/library/xml.etree.elementtree.rst
index 7948b2ed78f4d0..eedaa5845e15c7 100644
--- a/Doc/library/xml.etree.elementtree.rst
+++ b/Doc/library/xml.etree.elementtree.rst
@@ -710,15 +710,16 @@ Functions
 
 .. function:: tostring(element, encoding="us-ascii", method="xml", *, \
                        xml_declaration=None, default_namespace=None, \
-                       short_empty_elements=True, standalone=None)
+                       validate=False, short_empty_elements=True, \
+                       standalone=None)
 
    Generates a string representation of an XML element, including all
    subelements.  *element* is an :class:`Element` instance.  *encoding* [1]_ is
    the output encoding (default is US-ASCII).  Use ``encoding="unicode"`` to
    generate a Unicode string (otherwise, a bytestring is generated).  *method*
    is either ``"xml"``, ``"html"`` or ``"text"`` (default is ``"xml"``).
-   *xml_declaration*, *default_namespace*, *short_empty_elements* and
-   *standalone* has the same meaning as in :meth:`ElementTree.write`.
+   *xml_declaration*, *default_namespace*, *validate*, *short_empty_elements*
+   and *standalone* have the same meaning as in :meth:`ElementTree.write`.
    Returns an (optionally) encoded string containing the XML data.
 
    .. versionchanged:: 3.4
@@ -734,18 +735,22 @@ Functions
    .. versionchanged:: next
       Added the *standalone* parameter.
 
+   .. versionchanged:: next
+      Added the *validate* parameter.
+
 
 .. function:: tostringlist(element, encoding="us-ascii", method="xml", *, \
                            xml_declaration=None, default_namespace=None, \
-                           short_empty_elements=True, standalone=None)
+                           validate=False, short_empty_elements=True, \
+                           standalone=None)
 
    Generates a string representation of an XML element, including all
    subelements.  *element* is an :class:`Element` instance.  *encoding* [1]_ is
    the output encoding (default is US-ASCII).  Use ``encoding="unicode"`` to
    generate a Unicode string (otherwise, a bytestring is generated).  *method*
    is either ``"xml"``, ``"html"`` or ``"text"`` (default is ``"xml"``).
-   *xml_declaration*, *default_namespace*, *short_empty_elements* and
-   *standalone* has the same meaning as in :meth:`ElementTree.write`.
+   *xml_declaration*, *default_namespace*, *validate*, *short_empty_elements*
+   and *standalone* have the same meaning as in :meth:`ElementTree.write`.
    Returns a list of (optionally) encoded strings containing the XML data.
    It does not guarantee any specific sequence,
    except that ``b"".join(tostringlist(element)) == tostring(element)``.
@@ -765,6 +770,9 @@ Functions
    .. versionchanged:: next
       Added the *standalone* parameter.
 
+   .. versionchanged:: next
+      Added the *validate* parameter.
+
 
 .. function:: XML(text, parser=None)
 
@@ -1201,7 +1209,8 @@ ElementTree Objects
 
    .. method:: write(file, encoding="us-ascii", xml_declaration=None, \
                      default_namespace=None, method="xml", *, \
-                     short_empty_elements=True, standalone=None)
+                     validate=False, short_empty_elements=True, \
+                     standalone=None)
 
       Writes the element tree to a file, as XML.  *file* is a file name, or a
       :term:`file object` opened for writing.  *encoding* [1]_ is the output
@@ -1212,6 +1221,15 @@ ElementTree Objects
       *default_namespace* sets the default XML namespace (for "xmlns").
       *method* is either ``"xml"``, ``"html"`` or ``"text"`` (default is
       ``"xml"``).
+
+      If *validate* is true, check that all characters are legal,
+      that element and attribute names are valid, and that the content
+      of comments, processing instructions and HTML elements
+      like ``<script>`` do not contain illegal sequences according
+      to the selected *method* (``"xml"`` or ``"html"``).
+      Raise :exc:`ValueError` if any check fails.
+      By default, or if *method* is ``"text"``, no validation is performed.
+
       The keyword-only *short_empty_elements* parameter controls the formatting
       of elements that contain no content.  If ``True`` (the default), they are
       emitted as a single self-closed tag, otherwise they are emitted as a pair
@@ -1241,6 +1259,9 @@ ElementTree Objects
       .. versionchanged:: next
          Added the *standalone* parameter.
 
+      .. versionchanged:: next
+         Added the *validate* parameter.
+
 
 This is the XML file that is going to be manipulated::
 
diff --git a/Doc/whatsnew/3.16.rst b/Doc/whatsnew/3.16.rst
index 3262acd87d6d49..72db3f0e794646 100644
--- a/Doc/whatsnew/3.16.rst
+++ b/Doc/whatsnew/3.16.rst
@@ -660,6 +660,12 @@ xml
   rather than defaulted from the DTD.
   (Contributed by Jason Orendorff and Serhiy Storchaka in :gh:`44871`.)
 
+* Add the *validate* option to :func:`~xml.etree.ElementTree.tostring`,
+  :func:`~xml.etree.ElementTree.tostringlist` and
+  :meth:`ElementTree.write <xml.etree.ElementTree.ElementTree.write>`,
+  which makes them check that the produced document is well-formed.
+  (Contributed by Serhiy Storchaka in :gh:`149468`.)
+
 zipfile
 -------
 
diff --git a/Lib/test/test_xml_etree.py b/Lib/test/test_xml_etree.py
index f9ff8c4c3541ed..8c20ba1ce8ded8 100644
--- a/Lib/test/test_xml_etree.py
+++ b/Lib/test/test_xml_etree.py
@@ -1545,6 +1545,192 @@ def test_attlist_default(self):
                          {'{http://www.w3.org/XML/1998/namespace}lang': 'eng'})
 
 
+class XMLValidationTest(unittest.TestCase):
+
+    def check(self, elem):
+        self.assertRaises(ValueError,
+            ET.tostring, elem, validate=True)
+        ET.tostring(elem)  # no exception
+
+    def check_valid(self, elem, expected):
+        self.assertEqual(ET.tostring(elem, validate=True), expected)
+
+    @support.subTests('text', ('a--b', ' B+, B, or B-',
+                               '\x00', '\x01', '\ud8ff', '\ufffe'))
+    def test_invalid_comment(self, text):
+        self.check(ET.Comment(text))
+
+    def test_invalid_processing_instruction(self):
+        self.check(ET.PI(''))
+        self.check(ET.PI('0'))
+        self.check(ET.PI('a/b'))
+        self.check(ET.PI('foo\xa0bar'))
+        self.check(ET.PI('foo\fbar'))
+        self.check(ET.PI('xml'))
+        self.check(ET.PI('XML'))
+        self.check(ET.PI('xml', 'encoding="UTF-8"'))
+        self.check(ET.PI('foo', 'a?>b'))
+        self.check(ET.PI('foo', '\x00'))
+        self.check(ET.PI('foo', '\x01'))
+        self.check(ET.PI('foo', '\ud8ff'))
+        self.check(ET.PI('foo', '\ufffe'))
+
+        self.check_valid(ET.PI('foo\tbar'), b'<?foo\tbar?>')
+        self.check_valid(ET.PI('foo\nbar'), b'<?foo\nbar?>')
+        self.check_valid(ET.PI('foo\rbar'), b'<?foo\rbar?>')
+
+    @support.subTests('name', ('', '0', 'a/b'))
+    def test_invalid_tag(self, name):
+        self.check(ET.Element(name))
+        self.check(ET.Element(ET.QName(name)))
+
+    @support.subTests('name', ('', '0', 'a/b'))
+    def test_invalid_attr_name(self, name):
+        self.check(ET.Element('tag', attrib={name: 'value'}))
+        self.check(ET.Element('tag', attrib={ET.QName(name): 'value'}))
+
+    @support.subTests('value', ('\x00', '\ud8ff', '\ufffe'))
+    def test_invalid_attr_value(self, value):
+        self.check(ET.Element('tag', attrib={'key': value}))
+        self.check(ET.Element('tag', attrib={'key': ET.QName(value)}))
+
+    @support.subTests('text', ('\x00', '\ud8ff', '\ufffe'))
+    def test_invalid_text(self, text):
+        elem = ET.Element('tag')
+        elem.text = text
+        self.check(elem)
+
+    @support.subTests('tail', ('\x00', '\ud8ff', '\ufffe'))
+    def test_invalid_tail(self, tail):
+        elem = ET.Element('tag')
+        elem.tail = tail
+        self.check(elem)
+
+    @support.subTests('text', ('\x00', '\ud8ff', '\ufffe'))
+    def test_invalid_text_without_tag(self, text):
+        elem = ET.Element(None)
+        elem.text = text
+        self.check(elem)
+
+    def test_invalid_subelements(self):
+        elem = ET.Element('tag')
+        subelem = ET.SubElement(elem, 'subtag')
+        ET.SubElement(subelem, '\x00')
+        self.check(elem)
+        elem.tag = None
+        self.check(elem)
+
+    @support.subTests('uri', ('\x00', '\ud8ff', '\ufffe'))
+    def test_invalid_namespace_uri(self, uri):
+        self.check(ET.Element('{%s}tag' % uri))
+        self.check(ET.Element(ET.QName(uri, 'tag')))
+
+
+class HTMLValidationTest(unittest.TestCase):
+
+    def check(self, elem):
+        self.assertRaises(ValueError,
+            ET.tostring, elem, method='html', validate=True)
+        ET.tostring(elem, method='html')  # no exception
+
+    @support.subTests('text', ('>', '->', 'a-->b', 'a--!>b',
+                               'a\x00b', 'a\ud8ffb'))
+    def test_invalid_comment(self, text):
+        self.check(ET.Comment(text))
+
+    @support.subTests('text', ('a>b', 'a\x00b', 'a\ud8ffb'))
+    def test_invalid_processing_instruction(self, text):
+        self.check(ET.PI(text))
+
+    @support.subTests('name', ('', '0', 'a/b'))
+    def test_invalid_tag(self, name):
+        self.check(ET.Element(name))
+        self.check(ET.Element(ET.QName(name)))
+
+    @support.subTests('name', ('?', '!', ' a', 'a b', 'a\nb', 'a>b',
+                               'a\x00b', 'a\ud8ffb'))
+    def test_invalid_tag_str_only(self, name):
+        self.check(ET.Element(name))
+
+    @support.subTests('name', ('', 'a/b'))
+    def test_invalid_attr_name(self, name):
+        self.check(ET.Element('tag', attrib={name: 'value'}))
+        self.check(ET.Element('tag', attrib={ET.QName(name): 'value'}))
+
+    @support.subTests('name', ('\x00', '\ud8ff', 'a=b',
+                               'a\x00b', 'a\ud8ffb'))
+    def test_invalid_attr_name_str_only(self, name):
+        self.check(ET.Element('tag', attrib={name: 'value'}))
+
+    @support.subTests('value', ('\x00', '\ud8ff'))
+    def test_invalid_attr_value(self, value):
+        self.check(ET.Element('tag', attrib={'key': value}))
+        self.check(ET.Element('tag', attrib={'key': ET.QName(value)}))
+
+    @support.subTests('value', ('a"b', 'a&b'))
+    def test_invalid_attr_value_qname(self, value):
+        # a string value is escaped, a QName is written as is
+        self.check(ET.Element('tag', attrib={'key': ET.QName(value)}))
+
+    @support.subTests('text', ('\x00', '\ud8ff'))
+    def test_invalid_text(self, text):
+        elem = ET.Element('tag')
+        elem.text = text
+        self.check(elem)
+
+    @support.subTests('tail', ('\x00', '\ud8ff'))
+    def test_invalid_tail(self, tail):
+        elem = ET.Element('tag')
+        elem.tail = tail
+        self.check(elem)
+
+    @support.subTests('text', ('\x00', '\ud8ff'))
+    def test_invalid_text_without_tag(self, text):
+        elem = ET.Element(None)
+        elem.text = text
+        self.check(elem)
+
+    def test_invalid_subelements(self):
+        elem = ET.Element('tag')
+        subelem = ET.SubElement(elem, 'subtag')
+        ET.SubElement(subelem, '\x00')
+        self.check(elem)
+        elem.tag = None
+        self.check(elem)
+
+    @support.subTests('uri', ('\x00', '\ud8ff'))
+    def test_invalid_namespace_uri(self, uri):
+        self.check(ET.Element('{%s}tag' % uri))
+        self.check(ET.Element(ET.QName(uri, 'tag')))
+
+    @support.subTests('tag', ("script", "style", "xmp", "iframe", "noembed", "noframes"))
+    def test_invalid_cdata_content(self, tag):
+        elem = ET.Element(tag.upper())
+        elem.text = 'a</%s>b' % tag.title()
+        self.check(elem)
+        elem.text = 'a</%s b' % tag.title()
+        self.check(elem)
+        elem.text = 'a</%s/b' % tag.title()
+        self.check(elem)
+        elem.text = 'a\x00b'
+        self.check(elem)
+        elem.text = 'a\ud8ffb'
+        self.check(elem)
+
+    @support.subTests('tag', ("script", "style", "xmp", "iframe", "noembed", "noframes"))
+    def test_cdata_subelements(self, tag):
+        elem = ET.Element(tag)
+        ET.SubElement(elem, 'subtag')
+        self.check(elem)
+
+    def test_invalid_plaintext_content(self):
+        elem = ET.Element('plaintext')
+        elem.text = 'a\x00b'
+        self.check(elem)
+        elem.text = 'a\ud8ffb'
+        self.check(elem)
+
+
 class IterparseTest(unittest.TestCase):
     # Test iterparse interface.
 
diff --git a/Lib/xml/etree/ElementTree.py b/Lib/xml/etree/ElementTree.py
index bed8c27df5a384..7b3d493e8073f9 100644
--- a/Lib/xml/etree/ElementTree.py
+++ b/Lib/xml/etree/ElementTree.py
@@ -99,6 +99,7 @@
 import weakref
 
 from . import ElementPath
+from .. import is_valid_name, is_valid_text
 
 
 # The white space characters of the XML specification (see XML 1.0, 2.3).
@@ -693,6 +694,7 @@ def write(self, file_or_filename,
               xml_declaration=None,
               default_namespace=None,
               method=None, *,
+              validate=False,
               short_empty_elements=True,
               standalone=None):
         """Write element tree to a file as XML.
@@ -713,6 +715,8 @@ def write(self, file_or_filename,
 
           *method* -- either "xml" (default), "html" or "text"
 
+          *validate* -- if true, validate the content
+
           *short_empty_elements* -- controls the formatting of elements
                                     that contain no content.  If True
                                     (default) they are emitted as a single
@@ -757,6 +761,7 @@ def write(self, file_or_filename,
                 qnames, namespaces = _namespaces(self._root, default_namespace)
                 serialize = _serialize[method]
                 serialize(write, self._root, qnames, namespaces,
+                          validate=validate,
                           short_empty_elements=short_empty_elements)
 
 # --------------------------------------------------------------------
@@ -873,23 +878,39 @@ def add_qname(qname):
             add_qname(text.text)
     return qnames, namespaces
 
-def _serialize_xml(write, elem, qnames, namespaces,
-                   short_empty_elements, **kwargs):
+def _serialize_xml(write, elem, qnames, namespaces, *,
+                   validate, short_empty_elements, **kwargs):
     tag = elem.tag
     text = elem.text
     if tag is Comment:
+        if validate:
+            if '--' in text or text.endswith('-') or not is_valid_text(text):
+                raise ValueError('invalid comment')
         write("<!--%s-->" % text)
     elif tag is ProcessingInstruction:
+        if validate:
+            m = re.search('[ \t\r\n]', text)
+            if m is not None:
+                target = text[:m.start()]
+            else:
+                target = text
+            if (not is_valid_name(target) or target.lower() == 'xml'
+                    or '?>' in text or not is_valid_text(text)):
+                raise ValueError(f'invalid processing instruction {elem.text!r}')
         write("<?%s?>" % text)
     else:
         tag = qnames[tag]
         if tag is None:
             if text:
-                write(_escape_cdata(text))
+                write(_escape_cdata(text, validate))
             for e in elem:
                 _serialize_xml(write, e, qnames, None,
+                               validate=validate,
                                short_empty_elements=short_empty_elements)
         else:
+            if validate:
+                if not is_valid_name(tag):
+                    raise ValueError(f'invalid element name {tag!r}')
             write("<" + tag)
             items = list(elem.items())
             if items or namespaces:
@@ -898,30 +919,40 @@ def _serialize_xml(write, elem, qnames, namespaces,
                                        key=lambda x: x[1]):  # sort on prefix
                         if k:
                             k = ":" + k
+                            if validate:
+                                if not is_valid_name(k):
+                                    raise ValueError(f'invalid namespace prefix {k[1:]!r}')
                         write(" xmlns%s=\"%s\"" % (
                             k,
-                            _escape_attrib(v)
+                            _escape_attrib(v, validate)
                             ))
                 for k, v in items:
                     if isinstance(k, QName):
                         k = k.text
+                    if validate:
+                        if not is_valid_name(qnames[k]):
+                            raise ValueError(f'invalid attribute name {k!r}')
                     if isinstance(v, QName):
                         v = qnames[v.text]
+                        if validate:
+                            if not is_valid_name(v):
+                                raise ValueError(f'invalid attribute value {v!r}')
                     else:
-                        v = _escape_attrib(v)
+                        v = _escape_attrib(v, validate)
                     write(" %s=\"%s\"" % (qnames[k], v))
             if text or len(elem) or not short_empty_elements:
                 write(">")
                 if text:
-                    write(_escape_cdata(text))
+                    write(_escape_cdata(text, validate))
                 for e in elem:
                     _serialize_xml(write, e, qnames, None,
+                                   validate=validate,
                                    short_empty_elements=short_empty_elements)
                 write("</" + tag + ">")
             else:
                 write(" />")
     if elem.tail:
-        write(_escape_cdata(elem.tail))
+        write(_escape_cdata(elem.tail, validate))
 
 _CDATA_CONTENT_ELEMENTS = {"script", "style", "xmp", "iframe", "noembed",
                            "noframes", "plaintext"}
@@ -930,21 +961,37 @@ def _serialize_xml(write, elem, qnames, namespaces,
               "img", "input", "isindex", "link", "meta", "param", "source",
               "track", "wbr", "plaintext"}
 
-def _serialize_html(write, elem, qnames, namespaces, **kwargs):
+def _is_valid_html_text(text):
+    return re.search('[\x00\ud800-\udfff]', text) is None
+
+def _serialize_html(write, elem, qnames, namespaces, *, validate=True, **kwargs):
     tag = elem.tag
     text = elem.text
     if tag is Comment:
+        if validate:
+            if (re.prefixmatch('-?>', text) or re.search('--!?>', text)
+                    or not _is_valid_html_text(text)):
+                raise ValueError('invalid comment')
         write("<!--%s-->" % text)
     elif tag is ProcessingInstruction:
+        if validate:
+            if '>' in text or not _is_valid_html_text(text):
+                raise ValueError(f'invalid processing instruction {text!r}')
         write("<?%s?>" % text)
     else:
         tag = qnames[tag]
         if tag is None:
             if text:
+                if validate:
+                    if not _is_valid_html_text(text):
+                        raise ValueError('invalid characters')
                 write(_escape_cdata(text))
             for e in elem:
-                _serialize_html(write, e, qnames, None)
+                _serialize_html(write, e, qnames, None, validate=validate)
         else:
+            if validate:
+                if not re.fullmatch('[A-Za-z][^\0\t\n\r\f />\ud800-\udfff]*+', tag):
+                    raise ValueError(f'invalid element name {tag!r}')
             write("<" + tag)
             items = list(elem.items())
             if items or namespaces:
@@ -953,6 +1000,12 @@ def _serialize_html(write, elem, qnames, namespaces, **kwargs):
                                        key=lambda x: x[1]):  # sort on prefix
                         if k:
                             k = ":" + k
+                        if validate:
+                            if not re.fullmatch('[^\0\t\n\r\f />=\ud800-\udfff]++', k):
+                                raise ValueError(f'invalid namespace prefix {k[1:]!r}')
+                        if validate:
+                            if not _is_valid_html_text(v):
+                                raise ValueError('invalid characters')
                         write(" xmlns%s=\"%s\"" % (
                             k,
                             _escape_attrib(v)
@@ -961,26 +1014,49 @@ def _serialize_html(write, elem, qnames, namespaces, **kwargs):
                     if isinstance(k, QName):
                         k = k.text
                     k = qnames[k]
+                    if validate:
+                        if not re.fullmatch('[^\0\t\n\r\f />\ud800-\udfff][^\0\t\n\r\f />=\ud800-\udfff]*+', k):
+                            raise ValueError(f'invalid attribute name {k!r}')
                     if v is None:
                         write(" %s" % k)  # empty attr
                     else:
                         if isinstance(v, QName):
                             v = qnames[v.text]
+                            if validate:
+                                if re.search('[\0"&\ud800-\udfff]', v):
+                                    raise ValueError(f'invalid attribute value {v!r}')
                         else:
+                            if validate:
+                                if not _is_valid_html_text(v):
+                                    raise ValueError(f'invalid attribute value {v!r}')
                             v = _escape_attrib_html(v)
                         write(" %s=\"%s\"" % (k, v))
             write(">")
             ltag = tag.lower()
             if text:
+                if validate:
+                    if not _is_valid_html_text(text):
+                        raise ValueError('invalid characters')
                 if ltag in _CDATA_CONTENT_ELEMENTS:
+                    if validate:
+                        if (ltag != "plaintext"
+                            and re.search(r'</%s(?=[\t\n\r\f />])' % ltag,
+                                          text, re.IGNORECASE|re.ASCII)):
+                            raise ValueError('invalid %s content' % ltag)
                     write(text)
                 else:
                     write(_escape_cdata(text))
+            if validate:
+                if ltag in _CDATA_CONTENT_ELEMENTS and len(elem):
+                    raise ValueError('subelements in %s element' % ltag)
             for e in elem:
-                _serialize_html(write, e, qnames, None)
+                _serialize_html(write, e, qnames, None, validate=validate)
             if ltag not in HTML_EMPTY:
                 write("</" + tag + ">")
     if elem.tail:
+        if validate:
+            if not _is_valid_html_text(elem.tail):
+                raise ValueError('invalid characters')
         write(_escape_cdata(elem.tail))
 
 def _serialize_text(write, elem):
@@ -1035,9 +1111,12 @@ def _raise_serialization_error(text):
         "cannot serialize %r (type %s)" % (text, type(text).__name__)
         )
 
-def _escape_cdata(text):
+def _escape_cdata(text, validate=False):
     # escape character data
     try:
+        if validate:
+            if not is_valid_text(text):
+                raise ValueError('invalid characters')
         # it's worth avoiding do-nothing calls for strings that are
         # shorter than 500 characters, or so.  assume that's, by far,
         # the most common case in most applications.
@@ -1051,9 +1130,12 @@ def _escape_cdata(text):
     except (TypeError, AttributeError):
         _raise_serialization_error(text)
 
-def _escape_attrib(text):
+def _escape_attrib(text, validate=False):
     # escape attribute value
     try:
+        if validate:
+            if not is_valid_text(text):
+                raise ValueError('invalid attribute value')
         if "&" in text:
             text = text.replace("&", "&amp;")
         if "<" in text:
@@ -1096,7 +1178,8 @@ def _escape_attrib_html(text):
 
 def tostring(element, encoding=None, method=None, *,
              xml_declaration=None, default_namespace=None,
-             short_empty_elements=True, standalone=None):
+             validate=False, short_empty_elements=True,
+             standalone=None):
     """Generate string representation of XML element.
 
     All subelements are included.  If encoding is "unicode", a string
@@ -1117,6 +1200,7 @@ def tostring(element, encoding=None, method=None, *,
                                xml_declaration=xml_declaration,
                                default_namespace=default_namespace,
                                method=method,
+                               validate=validate,
                                short_empty_elements=short_empty_elements,
                                standalone=standalone)
     return stream.getvalue()
@@ -1140,13 +1224,15 @@ def tell(self):
 
 def tostringlist(element, encoding=None, method=None, *,
                  xml_declaration=None, default_namespace=None,
-                 short_empty_elements=True, standalone=None):
+                 validate=False, short_empty_elements=True,
+                 standalone=None):
     lst = []
     stream = _ListDataStream(lst)
     ElementTree(element).write(stream, encoding,
                                xml_declaration=xml_declaration,
                                default_namespace=default_namespace,
                                method=method,
+                               validate=validate,
                                short_empty_elements=short_empty_elements,
                                standalone=standalone)
     return lst
diff --git a/Misc/NEWS.d/next/Library/2026-05-06-22-22-05.gh-issue-149468.IUSCzU.rst b/Misc/NEWS.d/next/Library/2026-05-06-22-22-05.gh-issue-149468.IUSCzU.rst
new file mode 100644
index 00000000000000..10be07afa8b36e
--- /dev/null
+++ b/Misc/NEWS.d/next/Library/2026-05-06-22-22-05.gh-issue-149468.IUSCzU.rst
@@ -0,0 +1,6 @@
+Add the *validate* option to :mod:`xml.etree.ElementTree` serialization
+functions, which allows to check that all characters are legal,
+that element and attribute names are valid, and that the content
+of comments, processing instructions and HTML elements
+like ``<script>`` do not contain illegal sequences according
+to the selected *method* (``"xml"`` or ``"html"``).