@@ -15,6 +15,7 @@
 
 - Fix crash when `# fmt: skip` follows the closing bracket of a multi-line call or
   subscript that isn't the last element of a collection or argument list (#5522)
+- Normalize hex codes in unicode escape sequences in f-strings (#5526)
 - Fix `--stdin` output ending in `\r\r\n` instead of `\r\n` when the input uses CRLF
   line endings and does not end with a newline, e.g. a notebook piped to `black -`
   (#5559)
 
@@ -82,6 +82,7 @@
 from black.strings import (
     fix_multiline_docstring,
     get_string_prefix,
+    normalize_fstring_unicode_escape_sequences,
     normalize_string_prefix,
     normalize_string_quotes,
     normalize_unicode_escape_sequences,
@@ -648,6 +649,7 @@ def visit_fstring(self, node: Node) -> Iterator[Line]:
         if any(child.type == STANDALONE_COMMENT for child in node.children):
             yield from self.visit_default(node)
             return
+        normalize_fstring_unicode_escape_sequences(node)
         # currently we don't want to format and split f-strings at all.
         string_leaf = fstring_tstring_to_string(node)
         node.replace(string_leaf)
@@ -668,6 +670,7 @@ def visit_tstring(self, node: Node) -> Iterator[Line]:
         if any(child.type == STANDALONE_COMMENT for child in node.children):
             yield from self.visit_default(node)
             return
+        normalize_fstring_unicode_escape_sequences(node)
         # currently we don't want to format and split t-strings at all.
         string_leaf = fstring_tstring_to_string(node)
         node.replace(string_leaf)
 
@@ -10,7 +10,8 @@
 
 from black._width_table import WIDTH_TABLE
 from black.mode import Mode, Preview
-from blib2to3.pytree import Leaf
+from blib2to3.pgen2 import token
+from blib2to3.pytree import Leaf, Node
 
 STRING_PREFIX_CHARS: Final = "fturbFTURB"  # All possible string prefix characters.
 STRING_PREFIX_RE: Final = re.compile(
@@ -330,13 +331,7 @@ def normalize_fstring_quotes(
     return middles, new_quote
 
 
-def normalize_unicode_escape_sequences(leaf: Leaf) -> None:
-    """Replace hex codes in Unicode escape sequences with lowercase representation."""
-    text = leaf.value
-    prefix = get_string_prefix(text)
-    if "r" in prefix.lower():
-        return
-
+def _normalize_unicode_escape_sequences_in_text(text: str) -> str:
     def replace(m: Match[str]) -> str:
         groups = m.groupdict()
         back_slashes = groups["backslashes"]
@@ -358,7 +353,67 @@ def replace(m: Match[str]) -> str:
             # \N{}
             return back_slashes + "N{" + groups["N"].upper() + "}"
 
-    leaf.value = re.sub(UNICODE_ESCAPE_RE, replace, text)
+    return re.sub(UNICODE_ESCAPE_RE, replace, text)
+
+
+def normalize_unicode_escape_sequences(leaf: Leaf) -> None:
+    """Replace hex codes in Unicode escape sequences with lowercase representation."""
+    text = leaf.value
+    prefix = get_string_prefix(text)
+    if "r" in prefix.lower():
+        return
+
+    leaf.value = _normalize_unicode_escape_sequences_in_text(text)
+
+
+def _normalize_fstring_field_node(node: Leaf | Node) -> None:
+    from black.nodes import syms
+
+    if isinstance(node, Leaf):
+        if node.type == token.STRING:
+            normalize_unicode_escape_sequences(node)
+        return
+
+    if node.type in (syms.fstring, syms.tstring):
+        normalize_fstring_unicode_escape_sequences(node)
+        return
+
+    for child in node.children:
+        _normalize_fstring_field_node(child)
+
+
+def normalize_fstring_unicode_escape_sequences(node: Node) -> None:
+    """Replace hex codes in Unicode escape sequences with lowercase representation
+    within an f-string or t-string node."""
+    from black.nodes import syms
+
+    if not node.children:
+        return
+
+    first_child = node.children[0]
+    is_raw_fstring = (
+        isinstance(first_child, Leaf) and "r" in first_child.value.rstrip("'\"").lower()
+    )
+
+    for child in node.children:
+        if child.type in (token.FSTRING_MIDDLE, token.TSTRING_MIDDLE):
+            if not is_raw_fstring:
+                assert isinstance(child, Leaf)
+                child.value = _normalize_unicode_escape_sequences_in_text(child.value)
+        elif child.type in (
+            syms.fstring_replacement_field,
+            syms.tstring_replacement_field,
+        ):
+            # If this is a debug f-string (e.g. f"{foo=}"), do not touch the
+            # expression before '=', as Python preserves the exact source expression.
+            if any(
+                isinstance(c, Leaf) and c.type == token.EQUAL and c.value == "="
+                for c in child.children
+            ):
+                continue
+
+            for subchild in child.children:
+                _normalize_fstring_field_node(subchild)
 
 
 @lru_cache(maxsize=4096)
 
@@ -13,6 +13,7 @@
 x = "\N{CYRILLIC small LETTER BYELORUSSIAN-UKRAINIAN I}"
 x = b"\x1Fdon't byte"
 x = rb"\x1Fdon't format"
+x = f"foo \xFF {1}"
 
 # output
 
@@ -31,3 +32,4 @@
 x = "\N{CYRILLIC SMALL LETTER BYELORUSSIAN-UKRAINIAN I}"
 x = b"\x1fdon't byte"
 x = rb"\x1Fdon't format"
+x = f"foo \xff {1}"
@@ -130,6 +130,15 @@
 
 f"{'\''}"
 f"{f'\''}"
+f"{'\xFF'}"
+f"{r'\xFF'}"
+f"{'\xFF'=}"
+f"outside \xAA {'\xBB'}"
+rf"outside \xAA {'\xBB'}"
+f"{f'hello \xEE'}"
+f"{'\N{ox}'}"
+f"{'\uFaCe'}"
+f"{'\U0001F60E'}"
 
 f'{1}\{{'
 f'{2} foo \{{[\}}'
@@ -269,6 +278,15 @@
 
 f"{'\''}"
 f"{f'\''}"
+f"{'\xff'}"
+f"{r'\xFF'}"
+f"{'\xFF'=}"
+f"outside \xaa {'\xbb'}"
+rf"outside \xAA {'\xbb'}"
+f"{f'hello \xee'}"
+f"{'\N{OX}'}"
+f"{'\uface'}"
+f"{'\U0001f60e'}"
 
 f"{1}\{{"
 f"{2} foo \{{[\}}"