@@ -222,6 +222,28 @@ For example:
             extra_kwargs = {'client': {'required': False}}
             validators = []  # Remove a default "unique together" constraint.
 
+### UniqueConstraint with conditions
+
+When using Django's `UniqueConstraint` with conditions that reference other model fields, DRF will automatically use
+`UniqueTogetherValidator` instead of field-level `UniqueValidator`. This ensures proper validation behavior when the constraint
+effectively involves multiple fields.
+
+For example, a single-field constraint with a condition becomes a multi-field validation when the condition references other fields.
+
+    class MyModel(models.Model):
+        name = models.CharField(max_length=100)
+        status = models.CharField(max_length=20)
+
+        class Meta:
+            constraints = [
+                models.UniqueConstraint(
+                    fields=['name'],
+                    condition=models.Q(status='active'),
+                    name='unique_active_name'
+                )
+            ]
+
+
 ### Updating nested serializers
 
 When applying an update to an existing instance, uniqueness validators will
 
@@ -1463,26 +1463,42 @@ def get_extra_kwargs(self):
 
     def get_unique_together_constraints(self, model):
         """
-        Returns iterator of (fields, queryset, condition_fields, condition, nulls_distinct),
-        each entry describes an unique together constraint on `fields` in `queryset`
-        with respect of constraint's `condition` and `nulls_distinct` option.
+        Returns iterator of (
+            fields,
+            queryset,
+            condition_fields,
+            condition,
+            nulls_distinct,
+            constraint,
+        ),
+        each entry describes a unique together constraint on `fields` in `queryset`
+        with respect of constraint's `condition`, `nulls_distinct` option, and
+        the original constraint object (for custom error messages/codes).
         """
         for parent_class in [model] + list(model._meta.parents):
             for unique_together in parent_class._meta.unique_together:
-                yield unique_together, model._default_manager, [], None, None
+                yield unique_together, model._default_manager, [], None, None, None
             for constraint in parent_class._meta.constraints:
-                if isinstance(constraint, models.UniqueConstraint) and len(constraint.fields) > 1:
+                if isinstance(constraint, models.UniqueConstraint):
                     if constraint.condition is None:
                         condition_fields = []
                     else:
-                        condition_fields = list(constraint.condition.referenced_base_fields)
-                    yield (
-                        constraint.fields,
-                        model._default_manager,
-                        condition_fields,
-                        constraint.condition,
-                        constraint.nulls_distinct,
-                    )
+                        condition_fields = list(
+                            constraint.condition.referenced_base_fields
+                        )
+
+                    # Combine constraint fields and condition fields. If the union
+                    # involves multiple fields, treat as unique-together validation
+                    required_fields = {*constraint.fields, *condition_fields}
+                    if constraint.fields and len(required_fields) > 1:
+                        yield (
+                            constraint.fields,
+                            model._default_manager,
+                            condition_fields,
+                            constraint.condition,
+                            constraint.nulls_distinct,
+                            constraint,
+                        )
 
     def get_uniqueness_extra_kwargs(self, field_names, declared_fields, extra_kwargs):
         """
@@ -1515,7 +1531,8 @@ def get_uniqueness_extra_kwargs(self, field_names, declared_fields, extra_kwargs
 
         # Include each of the `unique_together` and `UniqueConstraint` field names,
         # so long as all the field names are included on the serializer.
-        for unique_together_list, queryset, condition_fields, condition, nulls_distinct in self.get_unique_together_constraints(model):
+        for unique_together_list, queryset, condition_fields, condition, nulls_distinct, unused_constraint in self.get_unique_together_constraints(
+                model):
             unique_together_list_and_condition_fields = set(unique_together_list) | set(condition_fields)
             if model_fields_names.issuperset(unique_together_list_and_condition_fields):
                 unique_constraint_names |= unique_together_list_and_condition_fields
@@ -1629,7 +1646,12 @@ def _get_constraint_violation_error_message(self, constraint):
 
     def get_unique_together_validators(self):
         """
-        Determine a default set of validators for any unique_together constraints.
+        Determine a default set of validators for any unique_together constraints
+        and UniqueConstraint objects.
+
+        This method now preserves the original constraint object in the yielded
+        data from get_unique_together_constraints() to ensure custom violation
+        messages and error codes are correctly propagated to the validators.
         """
         # The field names we're passing though here only include fields
         # which may map onto a model field. Any dotted field name lookups
@@ -1653,17 +1675,11 @@ def get_unique_together_validators(self):
         for name, source in field_sources.items():
             source_map[source].append(name)
 
-        unique_constraint_by_fields = {
-            constraint.fields: constraint
-            for model_cls in (*self.Meta.model._meta.parents, self.Meta.model)
-            for constraint in model_cls._meta.constraints
-            if isinstance(constraint, models.UniqueConstraint)
-        }
-
         # Note that we make sure to check `unique_together` both on the
         # base model class, but also on any parent classes.
         validators = []
-        for unique_together, queryset, condition_fields, condition, nulls_distinct in self.get_unique_together_constraints(self.Meta.model):
+        for unique_together, queryset, condition_fields, condition, nulls_distinct, constraint in self.get_unique_together_constraints(
+                self.Meta.model):
             # Skip if serializer does not map to all unique together sources
             unique_together_and_condition_fields = set(unique_together) | set(condition_fields)
             if not set(source_map).issuperset(unique_together_and_condition_fields):
@@ -1687,16 +1703,17 @@ def get_unique_together_validators(self):
 
             field_names = tuple(source_map[f][0] for f in unique_together)
 
-            constraint = unique_constraint_by_fields.get(tuple(unique_together))
+            # Extract custom violation message and code from the constraint if available
             violation_error_message = self._get_constraint_violation_error_message(constraint) if constraint else None
+            violation_error_code = getattr(constraint, 'violation_error_code', None)
 
             validator = UniqueTogetherValidator(
                 queryset=queryset,
                 fields=field_names,
                 condition_fields=tuple(source_map[f][0] for f in condition_fields),
                 condition=condition,
                 message=violation_error_message,
-                code=getattr(constraint, 'violation_error_code', None),
+                code=violation_error_code,
                 nulls_distinct=nulls_distinct,
             )
             validators.append(validator)
 
@@ -79,10 +79,18 @@ def get_unique_validators(field_name, model_field):
     unique_error_message = get_unique_error_message(model_field)
     queryset = model_field.model._default_manager
     for condition in conditions:
-        yield UniqueValidator(
-            queryset=queryset if condition is None else queryset.filter(condition),
-            message=unique_error_message
+        condition_fields = (
+            set(condition.referenced_base_fields)
+            if condition is not None
+            else set()
         )
+        # Only use UniqueValidator if the union of field and condition fields is 1
+        # (i.e. no additional fields referenced in conditions)
+        if len(field_set | condition_fields) == 1:
+            yield UniqueValidator(
+                queryset=queryset if condition is None else queryset.filter(condition),
+                message=unique_error_message,
+            )
 
 
 def get_field_kwargs(field_name, model_field):
 
@@ -203,30 +203,52 @@ def __call__(self, attrs, serializer):
         queryset = self.filter_queryset(attrs, queryset, serializer)
         queryset = self.exclude_current_instance(attrs, queryset, serializer.instance)
 
-        checked_names = [
+        # Values of constraint fields only, resolved from attrs or instance.
+        # Used solely for the nulls_distinct guard, so condition fields
+        # do not accidentally cause validation to be skipped.
+        constraint_field_sources = [
             serializer.fields[field_name].source for field_name in self.fields
         ]
+        constraint_field_values = [
+            attrs[source] if source in attrs
+            else getattr(serializer.instance, source, None)
+            for source in constraint_field_sources
+        ]
+
+        # Combine constraint fields and condition fields to detect changes
+        # in either set of fields. This ensures that updates to condition
+        # fields also trigger revalidation.
+        checked_names = list(
+            {serializer.fields[field_name].source for field_name in self.fields}
+            | {serializer.fields[field_name].source for field_name in self.condition_fields}
+        )
+
         # Ignore validation if any field is None
         if serializer.instance is None:
-            checked_values = [attrs[field_name] for field_name in checked_names]
+            checked_values = [attrs.get(field_name) for field_name in checked_names]
         else:
-            # Ignore validation if all field values are unchanged
+            # Ignore validation if all field values are unchanged.
+            # Omitted fields are treated as unchanged; their value comes
+            # from the instance (as done for condition_kwargs below).
             checked_values = [
                 attrs[field_name]
                 for field_name in checked_names
-                if attrs[field_name] != getattr(serializer.instance, field_name)
+                if field_name in attrs and attrs[field_name] != getattr(serializer.instance, field_name, None)
             ]
 
         condition_sources = (serializer.fields[field_name].source for field_name in self.condition_fields)
         condition_kwargs = {
-            source: attrs[source]
+            source: attrs.get(source)
             if source in attrs
-            else getattr(serializer.instance, source)
+            else getattr(serializer.instance, source, None)
             for source in condition_sources
         }
+
         if checked_values:
-            # Skip validation for None values unless nulls_distinct is False
-            if self.nulls_distinct is not False and None in checked_values:
+            # Skip validation for None values in *constraint* fields unless
+            # nulls_distinct is False. Condition fields are intentionally
+            # excluded here.
+            if self.nulls_distinct is not False and any(v is None for v in constraint_field_values):
                 return
             if qs_exists_with_condition(queryset, self.condition, condition_kwargs):
                 field_names = ', '.join(self.fields)