diff --git a/.changeset/fix_const_variants_in_unions.md b/.changeset/fix_const_variants_in_unions.md
@@ -0,0 +1,11 @@
+---
+default: patch
+---
+
+# Fix `const` variants in `anyOf`/`oneOf` unions
+
+Fixes #1263
+
+A union with a `const` member that wasn't the last option generated broken parsing code: the const check ran unguarded and returned (or raised) before the other variants were tried. For a response like `anyOf: [{const: "x"}, {$ref: ...}]` the model branch was unreachable, and for a model property like `anyOf: [{const: "auto"}, {type: integer}]` any integer raised a `ValueError`. Const members now get the same type check and fallthrough as every other union member.
+
+This also fixes `to_multipart()` for models with a `const` inside a union, which used to raise `TypeError: Subscripted generics cannot be used with class and instance checks`.
diff --git a/end_to_end_tests/functional_tests/generated_code_execution/test_unions.py b/end_to_end_tests/functional_tests/generated_code_execution/test_unions.py
@@ -1,7 +1,14 @@
+import json
+from unittest.mock import MagicMock
+
+import httpx
+import pytest
+
 from end_to_end_tests.functional_tests.helpers import (
     assert_model_decode_encode,
     assert_model_property_type_hint,
     with_generated_client_fixture,
+    with_generated_code_import,
     with_generated_code_imports,
 )
 
@@ -141,3 +148,150 @@ def test_type_hints(self, ModelWithUnion, ModelWithRequiredUnion, ModelWithUnion
         )
         assert_model_property_type_hint(ModelWithUnionOfOne, "thing", "ThingA | Unset")
         assert_model_property_type_hint(ModelWithUnionOfOne, "required_thing", "ThingA")
+
+
+@with_generated_client_fixture(
+    """
+components:
+  schemas:
+    ThingA:
+      type: object
+      properties:
+        propA: { type: "string" }
+      required: ["propA"]
+    ModelWithConstUnions:
+      type: object
+      properties:
+        sizeOrAuto:
+          anyOf:
+            - const: "auto"
+            - type: integer
+        thingOrNone:
+          oneOf:
+            - const: "none"
+            - $ref: "#/components/schemas/ThingA"
+        mixedConsts:
+          anyOf:
+            - const: 1
+            - const: "one"
+            - type: boolean
+"""
+)
+@with_generated_code_imports(
+    ".models.ModelWithConstUnions",
+    ".models.ThingA",
+)
+class TestUnionsWithConst:
+    """Regression tests for https://github.com/openapi-generators/openapi-python-client/issues/1263"""
+
+    def test_const_variant_matches(self, ModelWithConstUnions):
+        assert_model_decode_encode(
+            ModelWithConstUnions,
+            {"sizeOrAuto": "auto", "thingOrNone": "none", "mixedConsts": "one"},
+            ModelWithConstUnions(size_or_auto="auto", thing_or_none="none", mixed_consts="one"),
+        )
+        assert_model_decode_encode(
+            ModelWithConstUnions,
+            {"mixedConsts": 1},
+            ModelWithConstUnions(mixed_consts=1),
+        )
+
+    def test_falls_through_const_to_later_variants(self, ModelWithConstUnions, ThingA):
+        assert_model_decode_encode(
+            ModelWithConstUnions,
+            {"sizeOrAuto": 5, "thingOrNone": {"propA": "x"}, "mixedConsts": True},
+            ModelWithConstUnions(size_or_auto=5, thing_or_none=ThingA(prop_a="x"), mixed_consts=True),
+        )
+
+    def test_wrong_value_of_right_type_is_not_accepted_as_const(self, ModelWithConstUnions):
+        with pytest.raises(TypeError):
+            ModelWithConstUnions.from_dict({"thingOrNone": "something else"})
+
+    def test_type_hints(self, ModelWithConstUnions):
+        assert_model_property_type_hint(ModelWithConstUnions, "size_or_auto", "int | Literal['auto'] | Unset")
+
+
+@with_generated_client_fixture(
+    """
+paths:
+  "/thing":
+    get:
+      operationId: getThing
+      responses:
+        "200":
+          description: Success
+          content:
+            application/json:
+              schema:
+                anyOf:
+                  - const: "Why have a fixed response? I dunno"
+                  - $ref: "#/components/schemas/Thing"
+components:
+  schemas:
+    Thing:
+      type: object
+      properties:
+        value: { type: "string" }
+      required: ["value"]
+"""
+)
+@with_generated_code_imports(
+    ".api.default.get_thing.sync",
+    ".client.Client",
+    ".models.Thing",
+)
+class TestResponseUnionWithConst:
+    """Regression tests for https://github.com/openapi-generators/openapi-python-client/issues/1263"""
+
+    @staticmethod
+    def _client_returning(Client, body):
+        mock_httpx_client = MagicMock(spec=httpx.Client)
+        mock_response = MagicMock(spec=httpx.Response)
+        mock_response.status_code = 200
+        mock_response.json.return_value = body
+        mock_response.content = json.dumps(body).encode()
+        mock_response.headers = {}
+        mock_httpx_client.request.return_value = mock_response
+        client = Client(base_url="https://api.example.com")
+        client.set_httpx_client(mock_httpx_client)
+        return client
+
+    def test_parses_const_variant(self, sync, Client):
+        client = self._client_returning(Client, "Why have a fixed response? I dunno")
+        assert sync(client=client) == "Why have a fixed response? I dunno"
+
+    def test_parses_model_variant(self, sync, Client, Thing):
+        client = self._client_returning(Client, {"value": "x"})
+        assert sync(client=client) == Thing(value="x")
+
+
+@with_generated_client_fixture(
+    """
+paths:
+  "/upload":
+    post:
+      operationId: upload
+      requestBody:
+        content:
+          multipart/form-data:
+            schema:
+              $ref: "#/components/schemas/Form"
+      responses:
+        "200":
+          description: Success
+components:
+  schemas:
+    Form:
+      type: object
+      properties:
+        sizeOrAuto:
+          anyOf:
+            - const: "auto"
+            - type: integer
+"""
+)
+@with_generated_code_import(".models.Form")
+class TestMultipartUnionWithConst:
+    def test_to_multipart(self, Form):
+        assert Form(size_or_auto="auto").to_multipart() == [("sizeOrAuto", (None, "auto", "text/plain"))]
+        assert Form(size_or_auto=3).to_multipart() == [("sizeOrAuto", (None, b"3", "text/plain"))]
diff --git a/...-records/test-3-1-features-client/test_3_1_features_client/models/post_const_path_body.py b/...-records/test-3-1-features-client/test_3_1_features_client/models/post_const_path_body.py
@@ -56,12 +56,17 @@ def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
         def _parse_nullable(data: object) -> Literal["this or null goes in the body"] | None:
             if data is None:
                 return data
-            nullable_type_1 = cast(Literal["this or null goes in the body"], data)
-            if nullable_type_1 != "this or null goes in the body":
-                raise ValueError(
-                    f"nullable_type_1 must match const 'this or null goes in the body', got '{nullable_type_1}'"
-                )
-            return nullable_type_1
+            try:
+                if not isinstance(data, str):
+                    raise TypeError()
+                nullable_type_1 = cast(Literal["this or null goes in the body"], data)
+                if nullable_type_1 != "this or null goes in the body":
+                    raise ValueError(
+                        f"nullable_type_1 must match const 'this or null goes in the body', got '{nullable_type_1}'"
+                    )
+                return nullable_type_1
+            except (TypeError, ValueError, AttributeError, KeyError):
+                pass
             return cast(Literal["this or null goes in the body"] | None, data)
 
         nullable = _parse_nullable(d.pop("nullable"))

diff --git a/...ecords/test-3-1-features-client/test_3_1_features_client/models/post_prefix_items_body.py b/...ecords/test-3-1-features-client/test_3_1_features_client/models/post_prefix_items_body.py
@@ -60,12 +60,17 @@ def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
             for prefix_items_and_items_item_data in _prefix_items_and_items:
 
                 def _parse_prefix_items_and_items_item(data: object) -> float | Literal["prefix"] | str:
-                    prefix_items_and_items_item_type_0 = cast(Literal["prefix"], data)
-                    if prefix_items_and_items_item_type_0 != "prefix":
-                        raise ValueError(
-                            f"prefixItemsAndItems_item_type_0 must match const 'prefix', got '{prefix_items_and_items_item_type_0}'"
-                        )
-                    return prefix_items_and_items_item_type_0
+                    try:
+                        if not isinstance(data, str):
+                            raise TypeError()
+                        prefix_items_and_items_item_type_0 = cast(Literal["prefix"], data)
+                        if prefix_items_and_items_item_type_0 != "prefix":
+                            raise ValueError(
+                                f"prefixItemsAndItems_item_type_0 must match const 'prefix', got '{prefix_items_and_items_item_type_0}'"
+                            )
+                        return prefix_items_and_items_item_type_0
+                    except (TypeError, ValueError, AttributeError, KeyError):
+                        pass
                     return cast(float | Literal["prefix"] | str, data)
 
                 prefix_items_and_items_item = _parse_prefix_items_and_items_item(prefix_items_and_items_item_data)

diff --git a/openapi_python_client/parser/properties/const.py b/openapi_python_client/parser/properties/const.py
@@ -100,6 +100,10 @@ def get_type_string(
             return PythonCode(f"{lit.as_unembedded_code()} | Unset")
         return lit
 
+    def get_instance_type_string(self) -> PythonCode:
+        """The runtime type of the const value, used for `isinstance` checks (e.g., when choosing a union variant)"""
+        return PythonCode(type(self.value.raw_value).__name__)
+
     def get_imports(self, *, prefix: str) -> set[str]:
         """
         Get a set of import strings that should be included when this property is used somewhere

diff --git a/openapi_python_client/templates/property_templates/const_property.py.jinja b/openapi_python_client/templates/property_templates/const_property.py.jinja
@@ -4,6 +4,8 @@ if {{ property.python_name }} != {{ property.value.python_code | as_unembedded_c
     raise ValueError(f"{{ property.name | in_f_string_literal }} must match const {{ property.value.python_code | in_f_string_literal }}, got '{{'{' + property.python_name + '}' }}'")
 {%- endmacro %}
 
+{% macro check_type_for_construct(property, source) %}isinstance({{ source }}, {{ property.get_instance_type_string() | as_unembedded_code }}){% endmacro %}
+
 {% macro multipart(property, source, name) %}
 files.append(({{ name }}, (None, {{ source }}, "text/plain")))
 {% endmacro %}
diff --git a/tests/test_parser/test_properties/test_const.py b/tests/test_parser/test_properties/test_const.py
@@ -0,0 +1,22 @@
+import pytest
+
+from openapi_python_client.parser.properties import ConstProperty
+from openapi_python_client.strings import PythonCode, PythonIdentifier
+
+
+@pytest.mark.parametrize(
+    ("const", "expected"),
+    [("auto", "str"), (1, "int"), (1.5, "float"), (True, "bool")],
+)
+def test_get_instance_type_string(const, expected):
+    prop = ConstProperty.build(
+        const=const,
+        default=None,
+        name="prop",
+        python_name=PythonIdentifier("prop", ""),
+        required=True,
+        description=None,
+    )
+
+    assert isinstance(prop, ConstProperty)
+    assert prop.get_instance_type_string() == PythonCode(expected)