@@ -2511,21 +2511,22 @@ class DeveloperKey:
     """Information about a developer API key, as returned by the Admin API.
 
     :param key_id: Unique ID of the key.
-    :param label: Label assigned to the key.
+    :param label: Label assigned to the key, or None if absent.
     :param creation_time: Timestamp when the key was created.
     :param deactivated_time: Timestamp when the key was deactivated, if it was.
     :param is_deactivated: True if the key is deactivated.
-    :param usage_limits: Usage limits configured for the key.
+    :param usage_limits: Usage limits configured for the key, or None if
+        absent.
     """
 
     def __init__(
         self,
         key_id: str,
-        label: str,
+        label: Optional[str],
         creation_time: Optional[datetime.datetime],
         deactivated_time: Optional[datetime.datetime],
         is_deactivated: bool,
-        usage_limits: DeveloperKeyUsageLimits,
+        usage_limits: Optional[DeveloperKeyUsageLimits],
     ):
         self._key_id = key_id
         self._label = label
@@ -2535,6 +2536,8 @@ def __init__(
         self._usage_limits = usage_limits
 
     def __str__(self) -> str:
+        if self.label is None:
+            return f"DeveloperKey ({self.key_id})"
         return f'DeveloperKey "{self.label}" ({self.key_id})'
 
     @staticmethod
@@ -2543,14 +2546,16 @@ def from_json(json: Any) -> "DeveloperKey":
         json = _as_dict(json)
         return DeveloperKey(
             key_id=_str_or_empty(json, "key_id"),
-            label=_str_or_empty(json, "label"),
+            label=_str_or_none(json.get("label")),
             creation_time=_parse_utc_timestamp(json.get("creation_time")),
             deactivated_time=_parse_utc_timestamp(
                 json.get("deactivated_time")
             ),
             is_deactivated=json.get("is_deactivated") is True,
-            usage_limits=DeveloperKeyUsageLimits.from_json(
-                json.get("usage_limits")
+            usage_limits=(
+                DeveloperKeyUsageLimits.from_json(json["usage_limits"])
+                if isinstance(json.get("usage_limits"), dict)
+                else None
             ),
         )
 
@@ -2560,8 +2565,8 @@ def key_id(self) -> str:
         return self._key_id
 
     @property
-    def label(self) -> str:
-        """Returns the label of the key."""
+    def label(self) -> Optional[str]:
+        """Returns the label of the key, or None if the API sent none."""
         return self._label
 
     @property
@@ -2580,8 +2585,9 @@ def is_deactivated(self) -> bool:
         return self._is_deactivated
 
     @property
-    def usage_limits(self) -> DeveloperKeyUsageLimits:
-        """Returns the usage limits of the key."""
+    def usage_limits(self) -> Optional[DeveloperKeyUsageLimits]:
+        """Returns the usage limits of the key, or None if the API sent
+        none."""
         return self._usage_limits
 
 
@@ -2686,15 +2692,15 @@ class KeyUsage:
     """Usage of a single API key in an admin usage analytics report.
 
     :param api_key: Masked API key.
-    :param api_key_label: Label of the API key.
+    :param api_key_label: Label of the API key, or None if absent.
     :param usage: Usage of the API key.
     :param usage_date: Day of the usage, present when grouped by key and day.
     """
 
     def __init__(
         self,
         api_key: str,
-        api_key_label: str,
+        api_key_label: Optional[str],
         usage: AdminUsageBreakdown,
         usage_date: Optional[datetime.datetime] = None,
     ):
@@ -2709,7 +2715,7 @@ def from_json(json: Any) -> "KeyUsage":
         json = _as_dict(json)
         return KeyUsage(
             api_key=_str_or_empty(json, "api_key"),
-            api_key_label=_str_or_empty(json, "api_key_label"),
+            api_key_label=_str_or_none(json.get("api_key_label")),
             usage=AdminUsageBreakdown.from_json(json.get("usage")),
             usage_date=_parse_utc_timestamp(json.get("usage_date")),
         )
@@ -2720,8 +2726,8 @@ def api_key(self) -> str:
         return self._api_key
 
     @property
-    def api_key_label(self) -> str:
-        """Returns the label of the API key."""
+    def api_key_label(self) -> Optional[str]:
+        """Returns the label of the API key, or None if the API sent none."""
         return self._api_key_label
 
     @property
 
@@ -271,7 +271,7 @@ def test_response_with_malformed_values_is_parsed_tolerantly(mocked):
     assert report.start_date is None
     assert report.total_usage.total_characters == 0
     assert report.total_usage.speech_to_text_minutes == 1.5
-    assert [k.api_key_label for k in report.key_usages] == ["kept", ""]
+    assert [k.api_key_label for k in report.key_usages] == ["kept", None]
     assert report.key_and_day_usages == []
     assert tags.next_page is None
     assert [(u.custom_tag, u.usage_date) for u in tags.usage] == [
@@ -282,11 +282,27 @@ def test_response_with_malformed_values_is_parsed_tolerantly(mocked):
     assert keys[0].usage_limits.characters is None
     assert keys[1].creation_time is None
     assert keys[1].is_deactivated is False
-    assert keys[1].usage_limits.characters is None
+    assert keys[1].usage_limits is None
     assert keys[2].is_deactivated is False
     assert keys[2].usage_limits.characters is None
 
 
+def test_absent_optional_key_fields_are_none(mocked):
+    key_json = {
+        k: v
+        for k, v in DEVELOPER_KEY_JSON.items()
+        if k not in ("label", "usage_limits")
+    }
+    mocked.get(url("v2/admin/developer-keys"), json=[key_json])
+
+    key = make_admin_client().list_developer_keys()[0]
+
+    assert key.label is None
+    assert key.usage_limits is None
+    assert str(key) == f"DeveloperKey ({KEY_ID})"
+    assert "None" not in str(key)
+
+
 def test_create_developer_key(mocked):
     mocked.post(
         url("v2/admin/developer-keys"),