@@ -1386,6 +1386,49 @@ def list_namespaces_paginated(
             total_count=result.get("total_count", 0),
         )
 
+    def list_namespaces(
+        self,
+        *,
+        prefix: str | None = None,
+        limit: int | None = None,
+        timeout: float | None = None,
+    ) -> Iterator[ListNamespacesResponse]:
+        """List namespaces, automatically following pagination.
+
+        Yields one :class:`ListNamespacesResponse` per page. The generator
+        automatically follows pagination tokens until all pages have been
+        retrieved.
+
+        Args:
+            prefix (str | None): Return only namespaces whose names start with this prefix.
+            limit (int | None): Maximum number of namespaces to return per page.
+            timeout (float | None): Per-call timeout in seconds.
+
+        Yields:
+            :class:`ListNamespacesResponse` for each page of results.
+
+        Examples:
+            .. code-block:: python
+
+                for page in idx.list_namespaces(prefix="prod-"):
+                    for ns in page.namespaces:
+                        print(ns.name, ns.record_count)
+        """
+        pagination_token: str | None = None
+        while True:
+            page = self.list_namespaces_paginated(
+                prefix=prefix,
+                limit=limit,
+                pagination_token=pagination_token,
+                timeout=timeout,
+            )
+            if page.namespaces:
+                yield page
+            if page.pagination is not None and page.pagination.next is not None:
+                pagination_token = page.pagination.next
+            else:
+                break
+
     def describe_namespace(
         self,
         *,
 
@@ -1045,6 +1045,57 @@ def test_list_namespaces_generator_rest(client: Pinecone, shared_index_dim2: str
             assert isinstance(ns_item.record_count, int) and ns_item.record_count >= 0
 
 
+# ---------------------------------------------------------------------------
+# list_namespaces generator — gRPC
+# ---------------------------------------------------------------------------
+
+
+@pytest.mark.integration
+def test_list_namespaces_generator_grpc(client: Pinecone, shared_index_dim2: str) -> None:
+    # shared_index_dim2
+    """list_namespaces() generator on GrpcIndex yields ListNamespacesResponse pages;
+    generator follows pagination tokens automatically until exhausted.
+
+    Verifies claims:
+    - unified-ns-0007 (gRPC): The namespace list generator yields ListNamespacesResponse
+      pages; the paginated method returns one page (not auto-paginating).
+    """
+    ns = f"ns-{uuid.uuid4().hex[:8]}"
+    ns_a = f"{ns}-a"
+    ns_b = f"{ns}-b"
+    index = client.index(name=shared_index_dim2, grpc=True)
+
+    # Upsert one vector into each namespace to create them implicitly
+    index.upsert(vectors=[{"id": "lnsg-v1", "values": [0.1, 0.2]}], namespace=ns_a)
+    index.upsert(vectors=[{"id": "lnsg-v2", "values": [0.3, 0.4]}], namespace=ns_b)
+
+    # Poll until both namespaces appear
+    poll_until(
+        query_fn=lambda: index.list_namespaces_paginated(prefix=f"{ns}-", limit=100),
+        check_fn=lambda r: len(r.namespaces) >= 2,
+        timeout=120,
+        description="both test namespaces appear via list_namespaces_paginated (grpc)",
+    )
+
+    # --- Exercise the generator ---
+    pages = list(index.list_namespaces(prefix=f"{ns}-"))
+    assert len(pages) >= 1, "list_namespaces() generator must yield at least one page"
+
+    # Collect all namespace names across all yielded pages
+    all_ns_names = [ns_item.name for page in pages for ns_item in page.namespaces]
+    assert ns_a in all_ns_names, f"Expected {ns_a!r} in generator output; got {all_ns_names}"
+    assert ns_b in all_ns_names, f"Expected {ns_b!r} in generator output; got {all_ns_names}"
+
+    # Verify shape of every yielded page and its namespace descriptions
+    for page in pages:
+        assert isinstance(page, ListNamespacesResponse)
+        assert len(page.namespaces) >= 1, "Each yielded page must contain at least one namespace"
+        for ns_item in page.namespaces:
+            assert isinstance(ns_item, NamespaceDescription)
+            assert isinstance(ns_item.name, str) and ns_item.name.startswith(f"{ns}-")
+            assert isinstance(ns_item.record_count, int) and ns_item.record_count >= 0
+
+
 # ---------------------------------------------------------------------------
 # list_paginated multi-page — REST sync
 # ---------------------------------------------------------------------------
 
@@ -281,3 +281,93 @@ def test_grpc_list_namespaces_paginated_timeout_forwarded(self) -> None:
             pagination_token=None,
             timeout_s=2.5,
         )
+
+
+class TestGrpcListNamespaces:
+    def test_grpc_list_namespaces_yields_pages_single(self) -> None:
+        mock_channel = MagicMock()
+        idx = _make_grpc_index(mock_channel)
+
+        page = ListNamespacesResponse(
+            namespaces=[NamespaceDescription(name="a", record_count=1)],
+            pagination=None,
+            total_count=1,
+        )
+        idx.list_namespaces_paginated = MagicMock(return_value=page)
+
+        pages = list(idx.list_namespaces())
+
+        assert pages == [page]
+        idx.list_namespaces_paginated.assert_called_once_with(
+            prefix=None,
+            limit=None,
+            pagination_token=None,
+            timeout=None,
+        )
+
+    def test_grpc_list_namespaces_yields_pages_multi(self) -> None:
+        mock_channel = MagicMock()
+        idx = _make_grpc_index(mock_channel)
+
+        from pinecone.models.namespaces.models import Pagination
+
+        page1 = ListNamespacesResponse(
+            namespaces=[NamespaceDescription(name="a", record_count=1)],
+            pagination=Pagination(next="tok1"),
+            total_count=2,
+        )
+        page2 = ListNamespacesResponse(
+            namespaces=[NamespaceDescription(name="b", record_count=2)],
+            pagination=None,
+            total_count=2,
+        )
+        idx.list_namespaces_paginated = MagicMock(side_effect=[page1, page2])
+
+        pages = list(idx.list_namespaces())
+
+        assert pages == [page1, page2]
+        assert idx.list_namespaces_paginated.call_count == 2
+        second_call_kwargs = idx.list_namespaces_paginated.call_args_list[1].kwargs
+        assert second_call_kwargs["pagination_token"] == "tok1"
+
+    def test_grpc_list_namespaces_skips_empty_pages(self) -> None:
+        mock_channel = MagicMock()
+        idx = _make_grpc_index(mock_channel)
+
+        from pinecone.models.namespaces.models import Pagination
+
+        empty_page = ListNamespacesResponse(
+            namespaces=[],
+            pagination=Pagination(next="tok1"),
+            total_count=0,
+        )
+        final_page = ListNamespacesResponse(
+            namespaces=[NamespaceDescription(name="a", record_count=1)],
+            pagination=None,
+            total_count=1,
+        )
+        idx.list_namespaces_paginated = MagicMock(side_effect=[empty_page, final_page])
+
+        pages = list(idx.list_namespaces())
+
+        assert pages == [final_page]
+
+    def test_grpc_list_namespaces_limit_forwarded(self) -> None:
+        mock_channel = MagicMock()
+        idx = _make_grpc_index(mock_channel)
+
+        page = ListNamespacesResponse(
+            namespaces=[NamespaceDescription(name="a", record_count=1)],
+            pagination=None,
+            total_count=1,
+        )
+        idx.list_namespaces_paginated = MagicMock(return_value=page)
+
+        list(idx.list_namespaces(limit=5))
+
+        idx.list_namespaces_paginated.assert_called_once_with(
+            prefix=None,
+            limit=5,
+            pagination_token=None,
+            timeout=None,
+        )