XML Schema (XSD) erklärt: Aufbau, Datentypen, Beispiel

Aktualisiert am 9. Oktober 2026

Kurzantwort

Ein XML Schema (Dateiendung .xsd) ist ein Bauplan für XML-Dateien: Es legt fest, welche Elemente und Attribute vorkommen dürfen, in welcher Reihenfolge und mit welchem Datentyp. Ein Validator prüft dann automatisch, ob eine XML-Datei diesen Regeln entspricht. Die aktuelle Version ist XSD 1.1 (W3C-Empfehlung vom 5. April 2012), in der Praxis ist aber XSD 1.0 (Mai 2001) noch weit verbreiteter.

Was ist XML Schema?

XML-Schema ist eine vom World Wide Web Consortium ( W3C ) entwickelte Spezifikation, die eine standardisierte Methode zur Beschreibung der Struktur und der Einschränkungen von XML-Dokumenten bietet. Das Schema ist selbst ein XML-Dokument und nutzt den Namensraum http://www.w3.org/2001/XMLSchema, meist mit dem Präfix xs: oder xsd:.

Wichtig ist der Unterschied zwischen zwei Prüfstufen:

Wohlgeformt heißt: Die XML-Syntax stimmt (jedes Tag geschlossen, korrekt verschachtelt, genau ein Wurzelelement). Das prüft jeder XML-Parser. Die Regeln dazu findest du im Artikel zur Extensible Markup Language (XML): Syntax und Regeln im Detail.
Gültig (valide) heißt: Das Dokument ist wohlgeformt und hält sich an ein Schema. Genau dafür ist XSD da.

Ein Beispiel: <datum>26.09.2026</datum> ist wohlgeformtes XML. Verlangt das Schema aber den Typ xs:date, ist das Dokument ungültig, weil XSD Datumsangaben im Format JJJJ-MM-TT erwartet.

Wofür wird XSD eingesetzt?

Datenaustausch zwischen Firmen und Behörden: Schnittstellenbeschreibungen werden oft als XSD mitgeliefert, damit beide Seiten dieselben Regeln prüfen.
Webservices: Bei SOAP-Diensten beschreibt eine WSDL-Datei die Nachrichten, die Datentypen stecken darin typischerweise als XSD.
Konfigurations- und Build-Dateien: Viele Werkzeuge liefern XSD-Dateien mit, damit Editoren Autovervollständigung und Fehlerprüfung anbieten können.
Code-Generierung: Aus einem Schema lassen sich Klassen erzeugen, etwa für Java oder .NET.

Aufbau eines XML Schemas an einem Beispiel

Das folgende Schema beschreibt eine einfache Bestellung. Es wurde für diesen Artikel mit xmllint (libxml2) geprüft.

<?xml version="1.0" encoding="UTF-8"?>
<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema">

  <xs:element name="bestellung">
    <xs:complexType>
      <xs:sequence>
        <xs:element name="kunde" type="xs:string"/>
        <xs:element name="datum" type="xs:date"/>
        <xs:element name="position" type="positionTyp" maxOccurs="unbounded"/>
      </xs:sequence>
    </xs:complexType>
  </xs:element>

  <xs:complexType name="positionTyp">
    <xs:sequence>
      <xs:element name="artikel" type="xs:string"/>
      <xs:element name="menge" type="xs:positiveInteger"/>
      <xs:element name="preis" type="preisTyp"/>
    </xs:sequence>
    <xs:attribute name="nr" type="xs:positiveInteger" use="required"/>
  </xs:complexType>

  <xs:simpleType name="preisTyp">
    <xs:restriction base="xs:decimal">
      <xs:minInclusive value="0"/>
      <xs:fractionDigits value="2"/>
    </xs:restriction>
  </xs:simpleType>

</xs:schema>

Die wichtigsten Bausteine:

Baustein	Bedeutung im Beispiel
`xs:element`	Deklariert ein Element, z. B. `bestellung` als Wurzelelement
`xs:complexType`	Typ mit Kindelementen und/oder Attributen (`positionTyp`)
`xs:sequence`	Kindelemente müssen in genau dieser Reihenfolge stehen
`maxOccurs="unbounded"`	Beliebig viele `position`-Elemente erlaubt (Standard ist genau 1)
`xs:attribute` + `use="required"`	Attribut `nr` ist Pflicht
`xs:simpleType` + `xs:restriction`	Eigener Typ auf Basis eines eingebauten Typs, hier ein Preis ≥ 0 mit maximal zwei Nachkommastellen

Neben xs:sequence gibt es xs:choice (genau eines von mehreren Elementen) und xs:all (alle Elemente, Reihenfolge egal).

Das passende XML-Dokument

<?xml version="1.0" encoding="UTF-8"?>
<bestellung xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
            xsi:noNamespaceSchemaLocation="bestellung.xsd">
  <kunde>Muster GmbH</kunde>
  <datum>2026-09-26</datum>
  <position nr="1">
    <artikel>USB-C-Kabel</artikel>
    <menge>3</menge>
    <preis>9.90</preis>
  </position>
</bestellung>

Über xsi:noNamespaceSchemaLocation verweist das Dokument auf sein Schema. Nutzt das Schema einen eigenen Namensraum (targetNamespace), verwendest du stattdessen xsi:schemaLocation.

Eingebaute Datentypen: die wichtigsten

XSD kennt 19 primitive Datentypen und eine Reihe davon abgeleiteter Typen. Im Alltag brauchst du vor allem diese:

Typ	Beispielwert	Stolperfalle
`xs:string`	`Muster GmbH`	nimmt praktisch alles an
`xs:integer` / `xs:positiveInteger`	`3`	`positiveInteger` beginnt bei 1, nicht bei 0
`xs:decimal`	`9.90`	Dezimalpunkt statt Komma
`xs:boolean`	`true`, `false`, `1`, `0`	`ja`/`nein` ist ungültig
`xs:date`	`2026-09-26`	kein deutsches Format `26.09.2026`
`xs:dateTime`	`2026-09-26T14:30:00+02:00`	das `T` ist Pflicht
`xs:anyURI`	`https://example.com/`	–

Eigene Einschränkungen (Facets) baust du mit xs:restriction, zum Beispiel xs:pattern für reguläre Ausdrücke (etwa eine Postleitzahl mit [0-9]{5}), xs:enumeration für feste Wertelisten oder xs:maxLength für Textlängen.

XML gegen ein Schema validieren

Kommandozeile (Linux, macOS, Windows mit libxml2): xmllint --noout --schema bestellung.xsd bestellung.xml Ist alles korrekt, meldet das Tool bestellung.xml validates.
Python: Mit der Bibliothek lxml lädst du das Schema über etree.XMLSchema(etree.parse("bestellung.xsd")) und prüfst mit .validate(dokument).
Java und .NET: Beide bringen Schema-Validierung in der Standardbibliothek mit (javax.xml.validation bzw. XmlSchemaSet).
Editoren: Viele IDEs und XML-Editoren prüfen gegen ein verknüpftes Schema direkt beim Tippen.

So sehen die Fehlermeldungen aus, wenn du im Beispiel 26.09.2026 als Datum, 0 als Menge und 9,90 als Preis einträgst:

Element 'datum': '26.09.2026' is not a valid value of the atomic type 'xs:date'.
Element 'menge': '0' is not a valid value of the atomic type 'xs:positiveInteger'.
Element 'preis': '9,90' is not a valid value of the atomic type 'preisTyp'.

Genau das ist der Nutzen von XSD: Fehler fallen beim Einlesen auf und nicht erst, wenn falsche Daten im System gelandet sind.

XSD 1.0 oder XSD 1.1?

XSD 1.1 ergänzt vor allem Assertions (xs:assert): Regeln, die mit XPath-Ausdrücken formuliert werden, etwa „Enddatum muss nach Startdatum liegen". Dazu kommen die bedingte Typzuweisung (der Typ eines Elements hängt von einem Attributwert ab) und flexiblere Wildcards.

Der Haken: Nicht jeder Validator kann 1.1. Viele verbreitete Bibliotheken unterstützen nur XSD 1.0. Wenn du ein Schema für andere schreibst, bleib deshalb bei 1.0, solange du die 1.1-Funktionen nicht wirklich brauchst, und prüf vorher, welche Werkzeuge deine Partner einsetzen.

XSD im Vergleich zu DTD und RELAX NG

Kriterium	DTD	XML Schema (XSD)	RELAX NG
Syntax	eigene, nicht XML	XML	XML oder Kompaktsyntax
Datentypen	praktisch keine	umfangreich	über XSD-Datentypen
Namensräume	kaum unterstützt	ja	ja
Lesbarkeit	knapp	ausführlich, teils sperrig	vergleichsweise gut lesbar
Verbreitung heute	Altbestände, Entitäten	Standard im Unternehmensdatenaustausch	Nischen, z. B. Dokumentformate

Ergänzend gibt es Schematron für regelbasierte Prüfungen. Das Assertions-Konzept von XSD 1.1 ist davon inspiriert. Eine häufige Kritik an XSD ist die Komplexität der Spezifikation. Für einfache Strukturen reicht oft ein kleiner Teil davon, so wie im Beispiel oben.

FAQ

Was ist der Unterschied zwischen XML und XSD?

XML enthält die Daten, XSD beschreibt die Regeln, denen diese Daten folgen müssen. Eine XSD-Datei ist selbst XML. Eine Einführung für Einsteiger findest du unter Was ist XML? Einfach erklärt für Einsteiger.

Muss jede XML-Datei ein Schema haben?

Nein. Ein Schema ist optional. Sinnvoll ist es überall dort, wo Daten zwischen Systemen ausgetauscht oder automatisch verarbeitet werden.

Kann ich ein XSD aus einer XML-Datei erzeugen lassen?

Ja, viele XML-Editoren und IDEs können aus Beispieldateien ein Schema ableiten. Das Ergebnis ist aber nur ein Entwurf: Datentypen und Häufigkeiten (minOccurs, maxOccurs) solltest du von Hand prüfen.