diff --git a/composer.json b/composer.json
index d1744fe..0e77049 100644
--- a/composer.json
+++ b/composer.json
@@ -28,7 +28,7 @@
         "php-soap/wsdl": "^1.6",
         "php-soap/xml": "^1.7",
         "php-soap/wsdl-reader": "0.14.0",
-        "goetas-webservices/xsd-reader": "^0.4.5"
+        "goetas-webservices/xsd-reader": "^0.4.6"
     },
     "require-dev": {
         "vimeo/psalm": "^5.16",
diff --git a/src/Exception/SoapFaultException.php b/src/Exception/SoapFaultException.php
new file mode 100644
index 0000000..cd870ee
--- /dev/null
+++ b/src/Exception/SoapFaultException.php
@@ -0,0 +1,28 @@
+<?php
+declare(strict_types=1);
+
+namespace Soap\Encoding\Exception;
+
+use Psl\Str;
+use RuntimeException;
+use Soap\Encoding\Fault\SoapFault;
+
+final class SoapFaultException extends RuntimeException implements ExceptionInterface
+{
+    public function __construct(
+        private readonly SoapFault $fault
+    ) {
+        parent::__construct(
+            Str\format(
+                'SOAP Fault: %s (Code: %s)',
+                $this->fault->reason(),
+                $this->fault->code(),
+            ),
+        );
+    }
+
+    public function fault(): SoapFault
+    {
+        return $this->fault;
+    }
+}
diff --git a/src/Fault/Encoder/Soap11FaultEncoder.php b/src/Fault/Encoder/Soap11FaultEncoder.php
new file mode 100644
index 0000000..1d9735f
--- /dev/null
+++ b/src/Fault/Encoder/Soap11FaultEncoder.php
@@ -0,0 +1,99 @@
+<?php
+declare(strict_types=1);
+
+namespace Soap\Encoding\Fault\Encoder;
+
+use Soap\Encoding\Fault\Soap11Fault;
+use Soap\Encoding\Restriction\WhitespaceRestriction;
+use Soap\Xml\Xmlns;
+use VeeWee\Reflecta\Iso\Iso;
+use VeeWee\Xml\Dom\Document;
+use VeeWee\Xml\Writer\Writer;
+use function Psl\invariant;
+use function VeeWee\Xml\Dom\Xpath\Configurator\namespaces;
+use function VeeWee\Xml\Writer\Builder\children;
+use function VeeWee\Xml\Writer\Builder\element;
+use function VeeWee\Xml\Writer\Builder\namespaced_element;
+use function VeeWee\Xml\Writer\Builder\raw;
+use function VeeWee\Xml\Writer\Builder\value;
+use function VeeWee\Xml\Writer\Mapper\memory_output;
+
+/**
+ * @implements SoapFaultEncoder<Soap11Fault>
+ */
+final class Soap11FaultEncoder implements SoapFaultEncoder
+{
+    /**
+     * @return Iso<Soap11Fault, non-empty-string>
+     */
+    public function iso(): Iso
+    {
+        return new Iso(
+            $this->to(...),
+            $this->from(...)
+        );
+    }
+
+    /**
+     * @return non-empty-string
+     */
+    private function to(Soap11Fault $fault): string
+    {
+        $envNamespace = Xmlns::soap11Envelope()->value();
+
+        /** @var non-empty-string */
+        return Writer::inMemory()
+            ->write(children([
+                namespaced_element(
+                    $envNamespace,
+                    'env',
+                    'Fault',
+                    children([
+                        element(
+                            'faultcode',
+                            value($fault->faultCode),
+                        ),
+                        element(
+                            'faultstring',
+                            value($fault->faultString),
+                        ),
+                        ...(
+                            $fault->faultActor !== null
+                            ? [
+                                element(
+                                    'faultactor',
+                                    value($fault->faultActor)
+                                )
+                            ]
+                            : []
+                        ),
+                        ...($fault->detail !== null ? [raw($fault->detail)] : []),
+                    ])
+                )
+            ]))
+            ->map(memory_output());
+    }
+
+    /**
+     * @param non-empty-string $fault
+     */
+    private function from(string $fault): Soap11Fault
+    {
+        $document = Document::fromXmlString($fault);
+        $documentElement = $document->locateDocumentElement();
+
+        $envelopeUri = $documentElement->namespaceURI;
+        invariant($envelopeUri !== null, 'No SoapFault envelope namespace uri was specified.');
+        $xpath = $document->xpath(namespaces(['env' => $envelopeUri]));
+
+        $actor = $xpath->query('./faultactor');
+        $detail = $xpath->query('./detail');
+
+        return new Soap11Fault(
+            faultCode: WhitespaceRestriction::collapse($xpath->querySingle('./faultcode')->textContent),
+            faultString: WhitespaceRestriction::collapse($xpath->querySingle('./faultstring')->textContent),
+            faultActor: $actor->count() ? trim($actor->expectFirst()->textContent) : null,
+            detail: $detail->count() ? Document::fromXmlNode($detail->expectFirst())->stringifyDocumentElement() : null,
+        );
+    }
+}
diff --git a/src/Fault/Encoder/Soap12FaultEncoder.php b/src/Fault/Encoder/Soap12FaultEncoder.php
new file mode 100644
index 0000000..39cdede
--- /dev/null
+++ b/src/Fault/Encoder/Soap12FaultEncoder.php
@@ -0,0 +1,146 @@
+<?php
+declare(strict_types=1);
+
+namespace Soap\Encoding\Fault\Encoder;
+
+use Soap\Encoding\Fault\Soap12Fault;
+use Soap\Encoding\Restriction\WhitespaceRestriction;
+use VeeWee\Reflecta\Iso\Iso;
+use VeeWee\Xml\Dom\Document;
+use VeeWee\Xml\Writer\Writer;
+use function Psl\invariant;
+use function VeeWee\Xml\Dom\Xpath\Configurator\namespaces;
+use function VeeWee\Xml\Writer\Builder\children;
+use function VeeWee\Xml\Writer\Builder\namespaced_element;
+use function VeeWee\Xml\Writer\Builder\prefixed_element;
+use function VeeWee\Xml\Writer\Builder\raw;
+use function VeeWee\Xml\Writer\Builder\value;
+use function VeeWee\Xml\Writer\Mapper\memory_output;
+
+/**
+ * @implements SoapFaultEncoder<Soap12Fault>
+ */
+final class Soap12FaultEncoder implements SoapFaultEncoder
+{
+    private const ENV_NAMESPACE = 'http://www.w3.org/2003/05/soap-envelope';
+
+    /**
+     * @return Iso<Soap12Fault, non-empty-string>
+     */
+    public function iso(): Iso
+    {
+        return new Iso(
+            $this->to(...),
+            $this->from(...)
+        );
+    }
+
+    /**
+     * @return non-empty-string
+     */
+    private function to(Soap12Fault $fault): string
+    {
+        /** @var non-empty-string */
+        return Writer::inMemory()
+            ->write(children([
+                namespaced_element(
+                    self::ENV_NAMESPACE,
+                    'env',
+                    'Fault',
+                    children([
+                        prefixed_element(
+                            'env',
+                            'Code',
+                            children([
+                                prefixed_element(
+                                    'env',
+                                    'Value',
+                                    value($fault->code)
+                                ),
+                                ...(
+                                    $fault->subCode !== null
+                                    ? [
+                                        prefixed_element(
+                                            'env',
+                                            'Subcode',
+                                            children([
+                                                prefixed_element(
+                                                    'env',
+                                                    'Value',
+                                                    value($fault->subCode)
+                                                )
+                                            ])
+                                        )
+                                    ]
+                                    : []
+                                ),
+
+                            ])
+                        ),
+                        prefixed_element(
+                            'env',
+                            'Reason',
+                            children([
+                                prefixed_element(
+                                    'env',
+                                    'Text',
+                                    value($fault->reason)
+                                )
+                            ])
+                        ),
+                        ...(
+                            $fault->node !== null
+                                ? [
+                                    prefixed_element(
+                                        'env',
+                                        'Node',
+                                        value($fault->node)
+                                    )
+                                ]
+                                : []
+                        ),
+                        ...(
+                            $fault->role !== null
+                                ? [
+                                    prefixed_element(
+                                        'env',
+                                        'Role',
+                                        value($fault->role)
+                                    )
+                                ]
+                                : []
+                        ),
+                        ...($fault->detail !== null ? [raw($fault->detail)] : []),
+                    ])
+                )
+            ]))
+            ->map(memory_output());
+    }
+
+    /**
+     * @param non-empty-string $fault
+     */
+    private function from(string $fault): Soap12Fault
+    {
+        $document = Document::fromXmlString($fault);
+        $documentElement = $document->locateDocumentElement();
+
+        $envelopeUri = $documentElement->namespaceURI;
+        invariant($envelopeUri !== null, 'No SoapFault envelope namespace uri was specified.');
+        $xpath = $document->xpath(namespaces(['env' => $envelopeUri]));
+
+        $subCode = $xpath->query('./env:Code/env:Subcode/env:Value');
+        $node = $xpath->query('./env:Node');
+        $role = $xpath->query('./env:Role');
+        $detail = $xpath->query('./env:Detail');
+
+        return new Soap12Fault(
+            code: WhitespaceRestriction::collapse($xpath->querySingle('./env:Code/env:Value')->textContent),
+            reason: WhitespaceRestriction::collapse($xpath->querySingle('./env:Reason/env:Text')->textContent),
+            subCode: $subCode->count() ? WhitespaceRestriction::collapse($subCode->expectFirst()->textContent) : null,
+            node: $node->count() ? trim($node->expectFirst()->textContent) : null,
+            role: $role->count() ? trim($role->expectFirst()->textContent) : null,
+            detail: $detail->count() ? Document::fromXmlNode($detail->expectFirst())->stringifyDocumentElement() : null,
+        );
+    }
+}
diff --git a/src/Fault/Encoder/SoapFaultEncoder.php b/src/Fault/Encoder/SoapFaultEncoder.php
new file mode 100644
index 0000000..b9aca33
--- /dev/null
+++ b/src/Fault/Encoder/SoapFaultEncoder.php
@@ -0,0 +1,18 @@
+<?php
+declare(strict_types=1);
+
+namespace Soap\Encoding\Fault\Encoder;
+
+use Soap\Encoding\Fault\SoapFault;
+use VeeWee\Reflecta\Iso\Iso;
+
+/**
+ * @template TFault of SoapFault
+ */
+interface SoapFaultEncoder
+{
+    /**
+     * @return Iso<TFault, non-empty-string>
+     */
+    public function iso(): Iso;
+}
diff --git a/src/Fault/Guard/SoapFaultGuard.php b/src/Fault/Guard/SoapFaultGuard.php
new file mode 100644
index 0000000..4b12bf8
--- /dev/null
+++ b/src/Fault/Guard/SoapFaultGuard.php
@@ -0,0 +1,41 @@
+<?php
+declare(strict_types=1);
+
+namespace Soap\Encoding\Fault\Guard;
+
+use Soap\Encoding\Exception\SoapFaultException;
+use Soap\Encoding\Fault\Encoder\Soap11FaultEncoder;
+use Soap\Encoding\Fault\Encoder\Soap12FaultEncoder;
+use Soap\Xml\Xmlns;
+use VeeWee\Xml\Dom\Document;
+use function Psl\invariant;
+use function VeeWee\Xml\Dom\Xpath\Configurator\namespaces;
+
+final class SoapFaultGuard
+{
+    /**
+     * @throws SoapFaultException
+     */
+    public function __invoke(Document $envelope): void
+    {
+        $envelopeUri = $envelope->locateDocumentElement()->namespaceURI;
+        invariant($envelopeUri !== null, 'No SoapFault envelope namespace uri was specified.');
+        $xpath = $envelope->xpath(namespaces([
+            'env' => $envelopeUri,
+        ]));
+
+        $fault = $xpath->query('//env:Fault');
+        if (!$fault->count()) {
+            return;
+        }
+
+        $faultXml = Document::fromXmlNode($fault->expectFirst())->stringifyDocumentElement();
+
+        $fault = match($envelopeUri) {
+            Xmlns::soap11Envelope()->value() => (new Soap11FaultEncoder())->iso()->from($faultXml),
+            default => (new Soap12FaultEncoder())->iso()->from($faultXml),
+        };
+
+        throw new SoapFaultException($fault);
+    }
+}
diff --git a/src/Fault/Soap11Fault.php b/src/Fault/Soap11Fault.php
new file mode 100644
index 0000000..c56e74b
--- /dev/null
+++ b/src/Fault/Soap11Fault.php
@@ -0,0 +1,38 @@
+<?php
+declare(strict_types=1);
+
+namespace Soap\Encoding\Fault;
+
+/**
+ * @see https://www.w3.org/TR/2000/NOTE-SOAP-20000508/#_Toc478383507
+ *
+ *  A mandatory faultcode element information item
+ *  A mandatory faultstring element information item
+ *  An optional faultactor element information item
+ *  An optional detail element information item
+ */
+final class Soap11Fault implements SoapFault
+{
+    public function __construct(
+        public readonly string $faultCode,
+        public readonly string $faultString,
+        public readonly ?string $faultActor = null,
+        public readonly ?string $detail = null
+    ) {
+    }
+
+    public function code(): string
+    {
+        return $this->faultCode;
+    }
+
+    public function reason(): string
+    {
+        return $this->faultString;
+    }
+
+    public function detail(): ?string
+    {
+        return $this->detail;
+    }
+}
diff --git a/src/Fault/Soap12Fault.php b/src/Fault/Soap12Fault.php
new file mode 100644
index 0000000..7857c89
--- /dev/null
+++ b/src/Fault/Soap12Fault.php
@@ -0,0 +1,41 @@
+<?php
+declare(strict_types=1);
+
+namespace Soap\Encoding\Fault;
+
+/**
+ * https://www.w3.org/TR/soap12-part1/#soapfault
+ *
+ * A mandatory Code element information item (see 5.4.1 SOAP Code Element).
+ * A mandatory Reason element information item (see 5.4.2 SOAP Reason Element).
+ * An optional Node element information item (see 5.4.3 SOAP Node Element).
+ * An optional Role element information item (see 5.4.4 SOAP Role Element).
+ * An optional Detail element information item (see 5.4.5 SOAP Detail Element).
+ */
+final class Soap12Fault implements SoapFault
+{
+    public function __construct(
+        public readonly string $code,
+        public readonly string $reason,
+        public readonly ?string $subCode = null,
+        public readonly ?string $node = null,
+        public readonly ?string $role = null,
+        public readonly ?string $detail = null
+    ) {
+    }
+
+    public function code(): string
+    {
+        return $this->code;
+    }
+
+    public function reason(): string
+    {
+        return $this->reason;
+    }
+
+    public function detail(): ?string
+    {
+        return $this->detail;
+    }
+}
diff --git a/src/Fault/SoapFault.php b/src/Fault/SoapFault.php
new file mode 100644
index 0000000..a54586c
--- /dev/null
+++ b/src/Fault/SoapFault.php
@@ -0,0 +1,13 @@
+<?php
+declare(strict_types=1);
+
+namespace Soap\Encoding\Fault;
+
+interface SoapFault
+{
+    public function code(): string;
+
+    public function reason(): string;
+
+    public function detail(): ?string;
+}
diff --git a/src/Xml/Reader/SoapEnvelopeReader.php b/src/Xml/Reader/SoapEnvelopeReader.php
index ea00d77..ef080d4 100644
--- a/src/Xml/Reader/SoapEnvelopeReader.php
+++ b/src/Xml/Reader/SoapEnvelopeReader.php
@@ -3,6 +3,7 @@
 
 namespace Soap\Encoding\Xml\Reader;
 
+use Soap\Encoding\Fault\Guard\SoapFaultGuard;
 use Soap\Xml\Locator\SoapBodyLocator;
 use VeeWee\Xml\Dom\Document;
 use function VeeWee\Xml\Dom\Assert\assert_element;
@@ -14,8 +15,13 @@ final class SoapEnvelopeReader
      */
     public function __invoke(string $xml): string
     {
-        $document = Document::fromXmlString($xml);
-        $body = assert_element($document->locate(new SoapBodyLocator()));
+        $envelope = Document::fromXmlString($xml);
+
+        // Make sure it does not contain a fault response before parsing the body parts.
+        (new SoapFaultGuard())($envelope);
+
+        // Locate all body parts:
+        $body = assert_element($envelope->locate(new SoapBodyLocator()));
 
         return (new ChildrenReader())(Document::fromXmlNode($body)->toXmlString());
     }
diff --git a/tests/Unit/Fault/Encoder/AbstractFaultEncoderTests.php b/tests/Unit/Fault/Encoder/AbstractFaultEncoderTests.php
new file mode 100644
index 0000000..40b45b5
--- /dev/null
+++ b/tests/Unit/Fault/Encoder/AbstractFaultEncoderTests.php
@@ -0,0 +1,44 @@
+<?php
+declare(strict_types=1);
+
+namespace Soap\Encoding\Test\Unit\Fault\Encoder;
+
+use PHPUnit\Framework\TestCase;
+use Soap\Encoding\Encoder\Context;
+use Soap\Encoding\Encoder\XmlEncoder;
+use Soap\Encoding\Fault\Encoder\SoapFaultEncoder;
+use Soap\Encoding\Test\Unit\ContextCreatorTrait;
+
+abstract class AbstractFaultEncoderTests extends TestCase
+{
+    use ContextCreatorTrait;
+
+    /**
+     * @return iterable<int, array{encoder: XmlEncoder, context: Context, xml: string, data: mixed}>
+     */
+    abstract public static function provideIsomorphicCases(): iterable;
+
+    /**
+     *
+     * @dataProvider provideIsomorphicCases
+     */
+    public function test_it_can_decode_from_xml(SoapFaultEncoder $encoder, ?string $xml, mixed $data): void
+    {
+        $iso = $encoder->iso();
+        $actual = $iso->from($xml);
+
+        static::assertEquals($data, $actual);
+    }
+
+    /**
+     *
+     * @dataProvider provideIsomorphicCases
+     */
+    public function test_it_can_encode_into_xml(SoapFaultEncoder $encoder, ?string $xml, mixed $data): void
+    {
+        $iso = $encoder->iso();
+        $actual = $iso->to($data);
+
+        static::assertSame($xml, $actual);
+    }
+}
diff --git a/tests/Unit/Fault/Encoder/Soap11FaultEncoderTest.php b/tests/Unit/Fault/Encoder/Soap11FaultEncoderTest.php
new file mode 100644
index 0000000..2ec8857
--- /dev/null
+++ b/tests/Unit/Fault/Encoder/Soap11FaultEncoderTest.php
@@ -0,0 +1,65 @@
+<?php
+declare(strict_types=1);
+
+namespace Soap\Encoding\Test\Unit\Fault\Encoder;
+
+use PHPUnit\Framework\Attributes\CoversClass;
+use Soap\Encoding\Fault\Encoder\Soap11FaultEncoder;
+use Soap\Encoding\Fault\Soap11Fault;
+use VeeWee\Xml\Dom\Document;
+use function VeeWee\Xml\Dom\Configurator\loader;
+use function VeeWee\Xml\Dom\Configurator\trim_spaces;
+use function VeeWee\Xml\Dom\Loader\xml_string_loader;
+
+#[CoversClass(Soap11FaultEncoder::class)]
+#[CoversClass(Soap11Fault::class)]
+final class Soap11FaultEncoderTest extends AbstractFaultEncoderTests
+{
+    public static function provideIsomorphicCases(): iterable
+    {
+        $baseConfig = [
+            'encoder' => $encoder = new Soap11FaultEncoder(),
+        ];
+
+        yield 'required-fields-only' => [
+            ...$baseConfig,
+            'xml' => Document::configure(
+                trim_spaces(),
+                loader(xml_string_loader(
+                    <<<EOXML
+                    <env:Fault xmlns:env="http://schemas.xmlsoap.org/soap/envelope/">
+                        <faultcode>a:Microsoft.Dynamics.ServiceBrokerException</faultcode>
+                        <faultstring>Invalid input parameter x</faultstring>
+                    </env:Fault>
+                    EOXML
+                ))
+            )->stringifyDocumentElement(),
+            'data' => new Soap11Fault(
+                faultCode: 'a:Microsoft.Dynamics.ServiceBrokerException',
+                faultString: 'Invalid input parameter x',
+            ),
+        ];
+        yield 'all-fields' => [
+            ...$baseConfig,
+            'xml' => Document::configure(
+                trim_spaces(),
+                loader(xml_string_loader(
+                    <<<EOXML
+                    <env:Fault xmlns:env="http://schemas.xmlsoap.org/soap/envelope/">
+                        <faultcode>a:Microsoft.Dynamics.ServiceBrokerException</faultcode>
+                        <faultstring>Invalid input parameter x</faultstring>
+                        <faultactor>uri:actor</faultactor>
+                        <detail><element>value</element></detail>
+                    </env:Fault>
+                    EOXML
+                ))
+            )->stringifyDocumentElement(),
+            'data' => new Soap11Fault(
+                faultCode: 'a:Microsoft.Dynamics.ServiceBrokerException',
+                faultString: 'Invalid input parameter x',
+                faultActor: 'uri:actor',
+                detail: '<detail><element>value</element></detail>',
+            ),
+        ];
+    }
+}
diff --git a/tests/Unit/Fault/Encoder/Soap12FaultEncoderTest.php b/tests/Unit/Fault/Encoder/Soap12FaultEncoderTest.php
new file mode 100644
index 0000000..ed0ea37
--- /dev/null
+++ b/tests/Unit/Fault/Encoder/Soap12FaultEncoderTest.php
@@ -0,0 +1,111 @@
+<?php
+declare(strict_types=1);
+
+namespace Soap\Encoding\Test\Unit\Fault\Encoder;
+
+use PHPUnit\Framework\Attributes\CoversClass;
+use Soap\Encoding\Fault\Encoder\Soap12FaultEncoder;
+use Soap\Encoding\Fault\Soap12Fault;
+use VeeWee\Xml\Dom\Document;
+use function VeeWee\Xml\Dom\Configurator\loader;
+use function VeeWee\Xml\Dom\Configurator\trim_spaces;
+use function VeeWee\Xml\Dom\Loader\xml_string_loader;
+
+#[CoversClass(Soap12FaultEncoder::class)]
+#[CoversClass(Soap12Fault::class)]
+final class Soap12FaultEncoderTest extends AbstractFaultEncoderTests
+{
+    public static function provideIsomorphicCases(): iterable
+    {
+        $baseConfig = [
+            'encoder' => $encoder = new Soap12FaultEncoder(),
+        ];
+
+        yield 'required-fields-only' => [
+            ...$baseConfig,
+            'xml' => Document::configure(
+                trim_spaces(),
+                loader(xml_string_loader(
+                    <<<EOXML
+                    <env:Fault xmlns:env="http://www.w3.org/2003/05/soap-envelope">
+                        <env:Code>
+                            <env:Value>env:Sender</env:Value>
+                        </env:Code>
+                        <env:Reason>
+                            <env:Text>Sender Timeout</env:Text>
+                        </env:Reason>
+                    </env:Fault>
+                    EOXML
+                ))
+            )->stringifyDocumentElement(),
+            'data' => new Soap12Fault(
+                code: 'env:Sender',
+                reason: 'Sender Timeout',
+            ),
+        ];
+        yield 'subcode-and-details-example' => [
+            ...$baseConfig,
+            'xml' => Document::configure(
+                trim_spaces(),
+                loader(xml_string_loader(
+                    <<<EOXML
+                    <env:Fault xmlns:env="http://www.w3.org/2003/05/soap-envelope">
+                        <env:Code>
+                            <env:Value>env:Sender</env:Value>
+                            <env:Subcode>
+                                <env:Value>m:MessageTimeout</env:Value>
+                            </env:Subcode>
+                        </env:Code>
+                        <env:Reason>
+                            <env:Text>Sender Timeout</env:Text>
+                        </env:Reason>
+                        <env:Detail xmlns:m="http://www.example.org/timeouts" xmlns:env="http://www.w3.org/2003/05/soap-envelope"><m:MaxTime>P5M</m:MaxTime></env:Detail>
+                    </env:Fault>
+                    EOXML
+                ))
+            )->stringifyDocumentElement(),
+            'data' => new Soap12Fault(
+                code: 'env:Sender',
+                subCode: 'm:MessageTimeout',
+                reason: 'Sender Timeout',
+                detail: trim(<<<EOXML
+                <env:Detail xmlns:m="http://www.example.org/timeouts" xmlns:env="http://www.w3.org/2003/05/soap-envelope"><m:MaxTime>P5M</m:MaxTime></env:Detail>
+                EOXML)
+            ),
+        ];
+        yield 'full-example' => [
+            ...$baseConfig,
+            'xml' => Document::configure(
+                trim_spaces(),
+                loader(xml_string_loader(
+                    <<<EOXML
+                    <env:Fault xmlns:env="http://www.w3.org/2003/05/soap-envelope">
+                        <env:Code>
+                            <env:Value>env:Sender</env:Value>
+                            <env:Subcode>
+                                <env:Value>m:MessageTimeout</env:Value>
+                            </env:Subcode>
+                        </env:Code>
+                        <env:Reason>
+                            <env:Text>Sender Timeout</env:Text>
+                        </env:Reason>
+                        <env:Node>urn:node</env:Node>
+                        <env:Role>urn:role</env:Role>
+                        <env:Detail xmlns:m="http://www.example.org/timeouts" xmlns:env="http://www.w3.org/2003/05/soap-envelope"><m:MaxTime>P5M</m:MaxTime></env:Detail>
+                    </env:Fault>
+                    EOXML
+                ))
+            )->stringifyDocumentElement(),
+            'data' => new Soap12Fault(
+                code: 'env:Sender',
+                subCode: 'm:MessageTimeout',
+                reason: 'Sender Timeout',
+                node: 'urn:node',
+                role: 'urn:role',
+                detail: trim(<<<EOXML
+                <env:Detail xmlns:m="http://www.example.org/timeouts" xmlns:env="http://www.w3.org/2003/05/soap-envelope"><m:MaxTime>P5M</m:MaxTime></env:Detail>
+                EOXML)
+            ),
+        ];
+    }
+}
diff --git a/tests/Unit/Xml/Reader/SoapEnvelopeReaderTest.php b/tests/Unit/Xml/Reader/SoapEnvelopeReaderTest.php
index 79f1732..3075c3f 100644
--- a/tests/Unit/Xml/Reader/SoapEnvelopeReaderTest.php
+++ b/tests/Unit/Xml/Reader/SoapEnvelopeReaderTest.php
@@ -5,12 +5,16 @@
 namespace Soap\Encoding\Test\Unit\Xml\Writer;
 
 use PHPUnit\Framework\Attributes\CoversClass;
+use PHPUnit\Framework\Attributes\Test;
 use PHPUnit\Framework\TestCase;
+use Soap\Encoding\Exception\SoapFaultException;
+use Soap\Encoding\Fault\Guard\SoapFaultGuard;
 use Soap\Encoding\Xml\Reader\SoapEnvelopeReader;
 use Soap\Encoding\Xml\Writer\SoapEnvelopeWriter;
 use Soap\WsdlReader\Model\Definitions\SoapVersion;
 
 #[CoversClass(SoapEnvelopeWriter::class)]
+#[CoversClass(SoapFaultGuard::class)]
 final class SoapEnvelopeReaderTest extends TestCase
 {
     /**
@@ -25,6 +29,29 @@ public function test_it_can_read_a_soap_envelope(SoapVersion $version, string $e
         static::assertXmlStringEqualsXmlString($expected, $actual);
     }
 
+    #[Test]
+    public function it_fails_reading_on_soap_12_fault(): void
+    {
+        $this->expectException(SoapFaultException::class);
+
+        $reader = new SoapEnvelopeReader();
+        $reader(<<<EOXML
+            <soap:Envelope xmlns:soap="http://www.w3.org/2003/05/soap-envelope">
+                <soap:Body xmlns:soap="http://www.w3.org/2003/05/soap-envelope">
+                    <soap:Fault xmlns:env="http://www.w3.org/2003/05/soap-envelope">
+                        <soap:Code>
+                            <soap:Value>soap:Sender</soap:Value>
+                        </soap:Code>
+                        <soap:Reason>
+                            <soap:Text>Sender Timeout</soap:Text>
+                        </soap:Reason>
+                    </soap:Fault>
+                </soap:Body>
+            </soap:Envelope>
+        EOXML);
+
+    }
+
     public static function provideEnvelopeCases()
     {
         yield 'soap-1.1' => [