@@ -40,11 +40,13 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 - Added `get_languages_for_resource()` method to the `DeepLClient` class to
   retrieve the languages supported by a resource, with per-feature support
   information, via the `/v3/languages` endpoint. Resources are given as
-  `LanguageResourceName` values or strings.
+  `LanguageResourceName` values or strings; results are `LanguageSupport`
+  objects. Malformed responses raise `DeepLException`.
 - Added `get_language_resources()` method to the `DeepLClient` class to
   retrieve the API resources and their features via the
   `/v3/languages/resources` endpoint. Results are returned as
-  `LanguageResource` and `ResourceFeature` objects.
+  `LanguageResource` and `ResourceFeature` objects; `needs_source_support`
+  and `needs_target_support` are `False` when the API omits them.
 - Added `Language` constants for the target variants `de-CH`, `de-DE`,
   `es-ES`, `fr-CA`, and `fr-FR`.
 - Added the `enable_watermark` option to `translate_document()`,
 
@@ -821,8 +821,8 @@ a list of `LanguageResource` objects. Each has `name` (the resource name),
 `features` (a map from feature name to `ResourceFeature`) and
 `supports(feature)`. A `ResourceFeature` has `name`, `needs_source_support` and
 `needs_target_support`: `True` means the source (or target) language must
-support the feature for it to be available, `None` means the API did not
-specify it.
+support the feature for it to be available; they are `False` when the API
+omits them.
 
 ```python
 for resource in deepl_client.get_language_resources():
 
@@ -569,22 +569,30 @@ def target_lang(self) -> str:
         return self._target_lang
 
 
+def _required(json, key: str):
+    """Returns json[key]; raises KeyError if the field is missing or null."""
+    value = json[key]
+    if value is None:
+        raise KeyError(key)
+    return value
+
+
 class ResourceFeature:
     """A feature supported by a DeepL API resource, as returned by
     DeepLClient.get_language_resources().
 
     :param name: The feature name, for example "glossary" or "formality".
     :param needs_source_support: True if the source language must support
-        the feature for it to be available, None if not specified.
+        the feature for it to be available; False if the API omits it.
     :param needs_target_support: True if the target language must support
-        the feature for it to be available, None if not specified.
+        the feature for it to be available; False if the API omits it.
     """
 
     def __init__(
         self,
         name: str,
-        needs_source_support: Optional[bool] = None,
-        needs_target_support: Optional[bool] = None,
+        needs_source_support: bool = False,
+        needs_target_support: bool = False,
     ):
         self._name = name
         self._needs_source_support = needs_source_support
@@ -594,9 +602,9 @@ def __init__(
     def from_json(json) -> "ResourceFeature":
         """Create ResourceFeature from the given API JSON object."""
         return ResourceFeature(
-            name=json["name"],
-            needs_source_support=json.get("needs_source_support"),
-            needs_target_support=json.get("needs_target_support"),
+            name=_required(json, "name"),
+            needs_source_support=bool(json.get("needs_source_support")),
+            needs_target_support=bool(json.get("needs_target_support")),
         )
 
     def __str__(self) -> str:
@@ -608,15 +616,15 @@ def name(self) -> str:
         return self._name
 
     @property
-    def needs_source_support(self) -> Optional[bool]:
+    def needs_source_support(self) -> bool:
         """Returns True if the source language must support this feature,
-        or None if the API did not specify it."""
+        False otherwise (also when the API did not specify it)."""
         return self._needs_source_support
 
     @property
-    def needs_target_support(self) -> Optional[bool]:
+    def needs_target_support(self) -> bool:
         """Returns True if the target language must support this feature,
-        or None if the API did not specify it."""
+        False otherwise (also when the API did not specify it)."""
         return self._needs_target_support
 
 
@@ -641,7 +649,7 @@ def from_json(json) -> "LanguageResource":
             for feature in json.get("features") or []
         ]
         return LanguageResource(
-            name=json["name"],
+            name=_required(json, "name"),
             features={feature.name: feature for feature in features},
         )
 
@@ -2271,7 +2279,7 @@ def __init__(self, status: str):
     @staticmethod
     def from_json(json) -> "LanguageFeature":
         """Create LanguageFeature from the given API JSON object."""
-        return LanguageFeature(status=json["status"])
+        return LanguageFeature(status=_required(json, "status"))
 
     @property
     def status(self) -> str:
@@ -2319,11 +2327,11 @@ def from_json(json) -> "LanguageSupport":
         """Create LanguageSupport from the given API JSON object."""
         features = json.get("features") or {}
         return LanguageSupport(
-            code=json["lang"],
-            name=json["name"],
-            status=json["status"],
-            usable_as_source=bool(json["usable_as_source"]),
-            usable_as_target=bool(json["usable_as_target"]),
+            code=_required(json, "lang"),
+            name=_required(json, "name"),
+            status=_required(json, "status"),
+            usable_as_source=bool(_required(json, "usable_as_source")),
+            usable_as_target=bool(_required(json, "usable_as_target")),
             features={
                 name: LanguageFeature.from_json(feature)
                 for name, feature in features.items()
 
@@ -1001,8 +1001,15 @@ def get_languages_for_resource(
         status, content, json = self._api_call(endpoint, method="GET")
         self._raise_for_status(status, content, json)
 
-        languages = json if (json and isinstance(json, list)) else []
-        return [LanguageSupport.from_json(lang) for lang in languages]
+        if not isinstance(json, list):
+            raise DeepLException("Languages response is not a list")
+        languages = json
+        try:
+            return [LanguageSupport.from_json(lang) for lang in languages]
+        except (AttributeError, KeyError, TypeError, ValueError) as e:
+            raise DeepLException(
+                f"Malformed language in response: {e!r}"
+            ) from e
 
     def get_language_resources(self) -> List[LanguageResource]:
         """Retrieves the resources supported by the DeepL API, along with
@@ -1015,8 +1022,15 @@ def get_language_resources(self) -> List[LanguageResource]:
             "v3/languages/resources", method="GET"
         )
         self._raise_for_status(status, content, json)
-        resources = json if (json and isinstance(json, list)) else []
-        return [LanguageResource.from_json(r) for r in resources]
+        if not isinstance(json, list):
+            raise DeepLException("Language resources response is not a list")
+        resources = json
+        try:
+            return [LanguageResource.from_json(r) for r in resources]
+        except (AttributeError, KeyError, TypeError, ValueError) as e:
+            raise DeepLException(
+                f"Malformed language resource in response: {e!r}"
+            ) from e
 
     def get_all_style_rules(
         self,
 
@@ -212,7 +212,10 @@ def test_parses_language_resources(mocked):
     assert translate_text.supports("glossary")
     assert not translate_text.supports("nonexistent")
     glossary = translate_text.features["glossary"]
-    assert translate_text.features["formality"].needs_source_support is None
+    assert glossary.needs_source_support is True
+    formality = translate_text.features["formality"]
+    assert formality.needs_source_support is False
+    assert formality.needs_target_support is False
     assert str(glossary) == "glossary"
     assert voice.features == {}
 
@@ -268,3 +271,107 @@ def test_raises_deepl_exception_for_malformed_languages(
 
     with pytest.raises(deepl.DeepLException, match="Malformed language"):
         getattr(make_deepl_client(), method)()
+
+
+@pytest.mark.parametrize(
+    "language",
+    [
+        {
+            "name": "German",
+            "status": "stable",
+            "usable_as_source": True,
+            "usable_as_target": True,
+        },
+        {
+            "lang": "de",
+            "name": None,
+            "status": "stable",
+            "usable_as_source": True,
+            "usable_as_target": True,
+        },
+        {
+            "lang": "de",
+            "name": "German",
+            "status": "stable",
+            "usable_as_target": True,
+        },
+        {
+            "lang": "de",
+            "name": "German",
+            "status": "stable",
+            "usable_as_source": None,
+            "usable_as_target": True,
+        },
+        {
+            "lang": "de",
+            "name": "German",
+            "status": "stable",
+            "usable_as_source": True,
+            "usable_as_target": None,
+        },
+        {
+            "lang": "de",
+            "name": "German",
+            "status": "stable",
+            "usable_as_source": True,
+            "usable_as_target": True,
+            "features": {"formality": {}},
+        },
+        {
+            "lang": "de",
+            "name": "German",
+            "status": "stable",
+            "usable_as_source": True,
+            "usable_as_target": True,
+            "features": ["formality"],
+        },
+        "de",
+    ],
+)
+def test_raises_deepl_exception_for_malformed_languages_for_resource(
+    mocked, language
+):
+    mocked.get(url("v3/languages"), json=[language])
+
+    with pytest.raises(deepl.DeepLException, match="Malformed language"):
+        make_deepl_client().get_languages_for_resource("translate_text")
+
+
+@pytest.mark.parametrize(
+    "resource",
+    [
+        {"features": []},
+        {"name": None},
+        {"name": "translate_text", "features": [{"needs_source_support": 1}]},
+        {"name": "translate_text", "features": ["glossary"]},
+        "translate_text",
+    ],
+)
+def test_raises_deepl_exception_for_malformed_language_resources(
+    mocked, resource
+):
+    mocked.get(url("v3/languages/resources"), json=[resource])
+
+    with pytest.raises(
+        deepl.DeepLException, match="Malformed language resource"
+    ):
+        make_deepl_client().get_language_resources()
+
+
+@pytest.mark.parametrize("body", [{"message": "unexpected"}, "text"])
+@pytest.mark.parametrize(
+    "path, method",
+    [
+        ("v3/languages", "get_languages_for_resource"),
+        ("v3/languages/resources", "get_language_resources"),
+    ],
+)
+def test_raises_deepl_exception_for_non_list_language_reply(
+    mocked, path, method, body
+):
+    mocked.get(url(path), json=body)
+    client = make_deepl_client()
+    args = ["translate_text"] if method == "get_languages_for_resource" else []
+
+    with pytest.raises(deepl.DeepLException, match="not a list"):
+        getattr(client, method)(*args)