Introduction

The MalformedXML error means the service received XML that it could not parse or could not validate against the schema it expects. In practice, that usually comes from broken XML syntax, the wrong element order, missing required fields, or an API-specific XML document shape.

Separate Well-Formedness from Validation

Two different checks can fail here:

• the XML is not well-formed
• the XML is well-formed but does not match the schema

Well-formed XML obeys syntax rules such as proper nesting, quoted attributes, and exactly one root element. Schema validation is stricter. It checks whether the document uses the right tag names, required elements, allowed values, and order expected by the receiving API.

That distinction matters because a parser error and a schema error often produce the same high-level MalformedXML message.

Examples of Bad XML

This is not well-formed because the tags are mismatched:

<Request>
  <Bucket>reports</Buckett>
</Request>

This is well-formed, but it may still fail schema validation if the service expects Prefix before Status, or requires additional elements:

1<LifecycleConfiguration>
2  <Rule>
3    <Status>Enabled</Status>
4    <Prefix>logs/</Prefix>
5  </Rule>
6</LifecycleConfiguration>

An API that enforces a published XML schema may reject it even though the XML parser itself accepts it.

Validate XML Before Sending It

If you control the client, validate locally before making the request. Even a simple parse check removes a lot of guesswork.

1import xml.etree.ElementTree as ET
2
3xml_text = """
4<Request>
5    <Bucket>reports</Bucket>
6</Request>
7"""
8
9try:
10    root = ET.fromstring(xml_text)
11    print("Parsed root:", root.tag)
12except ET.ParseError as exc:
13    print("XML parse error:", exc)

This catches well-formedness problems such as broken nesting or missing quotes.

If you also have the XSD file, use a schema-aware validator. With lxml:

1from lxml import etree
2
3xml_doc = etree.fromstring(b"""
4<Request>
5    <Bucket>reports</Bucket>
6</Request>
7""")
8
9xsd_doc = etree.parse("schema.xsd")
10schema = etree.XMLSchema(xsd_doc)
11
12print(schema.validate(xml_doc))

Schema validation is the only reliable way to catch ordering and required-field issues before the request hits the remote service.

Common API Causes

This error shows up often with XML-based cloud APIs when sending configuration documents such as lifecycle rules, bucket policies, replication configs, or CORS settings. The most common causes are:

• incorrect namespace
• wrong element casing
• missing required child elements
• invalid enum values
• tags in the wrong order

When the service mentions a published schema, take that literally. Compare your request body line by line with the vendor's documented XML example.

A Practical Debugging Workflow

Use this order when debugging:

1. confirm the XML parses locally
2. compare the root element and namespaces
3. compare element order with the API example
4. check required and optional tags carefully
5. validate against the XSD if one exists

This is faster than changing tags randomly and retrying requests.

Also inspect whether your client library is generating XML for you. Sometimes the bug is not in the handwritten XML but in a serializer configuration or model object that produces the wrong document shape.

Common Pitfalls

• Assuming a well-formed XML document must also satisfy the API schema. Those are different checks.
• Ignoring namespaces and element ordering when the service validates against a strict schema.
• Hand-editing XML without running a local parse or validation step first.
• Comparing only tag names and forgetting that required values or enum names may also be wrong.
• Blaming the remote service before checking whether the client library or serializer generated unexpected XML.

Summary

• 'MalformedXML usually means a syntax error or a schema mismatch in the XML request body.'
• First determine whether the problem is well-formedness or validation.
• Parse locally to catch basic XML errors before making the request.
• If an XSD exists, validate against it instead of guessing.
• For XML-based APIs, namespaces, element order, and required fields are the main failure points.