@@ -327,21 +327,18 @@ def probabilities_(self) -> list[int]:
     @property
     def topic_representations_(self) -> dict[int, list[tuple[str, float]]]:
         """For backwards compatibility."""
-        representations = {}
-        for topic in self._topics:
-            representations[topic.id] = topic.representations["Main"].data
-        return representations if representations else None
+        return {topic.id: topic.representations["Main"].word_scores for topic in self._topics} or None
 
     @property
     def topic_aspects_(self) -> dict[int, dict[str, list[tuple[str, float]]]]:
         """For backwards compatibility."""
         first_topic = next(iter(self._topics), None)
-        aspect_names = list(first_topic.representations) if first_topic else []
-        aspects = {
-            aspect_name: {topic.id: topic.representations[aspect_name].data for topic in self._topics}
-            for aspect_name in aspect_names
+        aspects = first_topic.representations if first_topic else []
+        return {
+            name: {topic.id: topic.representations[name].word_scores for topic in self._topics}
+            for name in aspects
+            if name != "Main"
         }
-        return aspects
 
     @property
     def topic_sizes_(self) -> dict[int, int]:
@@ -364,9 +361,9 @@ def topic_labels_(self) -> dict[int, str]:
         return self._topics.labels
 
     @property
-    def custom_labels_(self) -> list[str]:
-        """For backwards compatibility."""
-        return [topic.label for topic in self._topics]
+    def custom_labels_(self) -> list[str] | None:
+        """For backwards compatibility. None until `set_topic_labels` is called."""
+        return self._topics.custom_labels
 
     @property
     def representative_docs_(self) -> dict[int, str]:
@@ -1129,6 +1126,29 @@ def get_topic(self, topic: int, full: bool = False) -> dict[str, tuple[str, floa
         else:
             return False
 
+    def get_representation(self, topic: int, aspect: str = "Main") -> TopicRepresentation:
+        """Return a topic's representation with its structure intact.
+
+        `get_topic` flattens every representation to words and scores, which loses the shape
+        of anything richer than keywords, such as the dictionary an LLM returns. This returns
+        the representation itself.
+
+        Arguments:
+            topic: A specific topic for which you want its representation
+            aspect: Which representation to return, defaulting to the main one
+
+        Returns:
+            The `TopicRepresentation` for that topic and aspect
+
+        Examples:
+        ```python
+        representation = topic_model.get_representation(12)
+        representation.words
+        ```
+        """
+        check_is_fitted(self)
+        return self._topics[topic].representations[aspect]
+
     def get_topic_info(self, topic: int | None = None) -> pl.DataFrame:
         """Get information about each topic including its ID, frequency, and name.
 
 
@@ -28,6 +28,20 @@ def words(self) -> list[str]:
         """
         return []
 
+    @property
+    def scores(self) -> list[float]:
+        """One score per word, weighting every word equally.
+
+        Only `Keywords` ranks the words within a topic. Everything else names the topic
+        instead of weighting what is in it, so no word is more representative than another.
+        """
+        return [1.0] * len(self.words)
+
+    @property
+    def word_scores(self) -> list[tuple[str, float]]:
+        """Words paired with their scores, which is how `get_topic` returns a topic."""
+        return list(zip(self.words, self.scores))
+
     def __str__(self) -> str:
         """String representation of the topic representation."""
         return str(self.data)
@@ -464,6 +478,17 @@ def labels(self) -> dict[int, str]:
         labels = {topic.id: topic.label if topic.label is not None else "" for topic in self.topics.values()}
         return dict(sorted(labels.items()))
 
+    @property
+    def custom_labels(self) -> list[str] | None:
+        """The labels a user set, or None when every label is still derived.
+
+        `Topic._label` is only filled in by `set_topic_labels`, which is what separates
+        a label the user chose from one generated out of the topic's keywords.
+        """
+        if all(topic._label is None for topic in self):
+            return None
+        return [topic.label for topic in self]
+
     @property
     def c_tf_idf(self) -> csr_matrix:
         """Get c-TF-IDF matrix for all topics in ascending topic ID order
 
@@ -2,6 +2,8 @@
 import pytest
 import polars as pl
 
+from bertopic._topics import Label, StructuredJSON
+
 
 @pytest.mark.parametrize(
     "model",
@@ -123,3 +125,60 @@ def test_get_topic_info(model, request):
         assert len(topic_model.get_topic_info(topic)) == 1
 
     assert len(topic_model.get_topic_info(200)) == 0
+
+
+@pytest.mark.parametrize(
+    "model",
+    [
+        ("kmeans_pca_topic_model"),
+        ("base_topic_model"),
+        ("custom_topic_model"),
+        ("merged_topic_model"),
+        ("reduced_topic_model"),
+        ("online_topic_model"),
+    ],
+)
+def test_get_topic_always_returns_words_with_scores(model, request):
+    topic_model = copy.deepcopy(request.getfixturevalue(model))
+
+    for topic in set(topic_model.topics_):
+        representation = topic_model.get_topic(topic)
+        assert all(isinstance(word, str) and isinstance(score, float) for word, score in representation)
+
+
+def test_get_topic_flattens_a_label_representation(base_topic_model):
+    """The regression this unit exists for: a label used to come back as a bare string.
+
+    `get_topic` returned `'label_0'`, so `visualize_barchart` raised on `for word, _ in ...`
+    and `_create_topic_vectors` would have embedded individual characters.
+    """
+    topic_model = copy.deepcopy(base_topic_model)
+    topic_ids = topic_model._topics.topic_ids()
+    topic_model._topics.set_data(
+        representations={"Main": {topic_id: Label(data=f"label_{topic_id}") for topic_id in topic_ids}}
+    )
+    first = topic_ids[0]
+
+    assert topic_model.get_topic(first) == [(f"label_{first}", 1.0)]
+    assert topic_model.visualize_barchart() is not None
+
+
+def test_get_representation_keeps_the_structure_get_topic_flattens(base_topic_model):
+    """Flattening is lossy, so the representation itself stays reachable."""
+    topic_model = copy.deepcopy(base_topic_model)
+    first = topic_model._topics.topic_ids()[0]
+    topic_model._topics.set_data(representations={"Main": {first: StructuredJSON(data={"topic": "cats"})}})
+
+    representation = topic_model.get_representation(first)
+
+    assert isinstance(representation, StructuredJSON)
+    assert representation.data == {"topic": "cats"}
+    assert topic_model.get_topic(first) == [("cats", 1.0)]
+
+
+def test_topic_aspects_excludes_the_main_representation(representation_topic_model):
+    """Aspects are the additional representations; Main is reached through `get_topic`."""
+    aspects = representation_topic_model.topic_aspects_
+
+    assert "Main" not in aspects
+    assert "MMR" in aspects
@@ -40,6 +40,9 @@ def test_generate_topic_labels(model, request):
 def test_set_labels(model, request):
     topic_model = copy.deepcopy(request.getfixturevalue(model))
 
+    # Nothing is custom until the user says so, which is what the plotting guards test for
+    assert topic_model.custom_labels_ is None
+
     labels = topic_model.generate_topic_labels()
     topic_model.set_topic_labels(labels)
     assert topic_model.custom_labels_ == labels
 
@@ -24,7 +24,17 @@
 from scipy.sparse import csr_matrix
 
 from bertopic._corpus import Corpus
-from bertopic._topics import Images, Keywords, Topic, TopicHierarchy, TopicMapping, Topics, TopicType
+from bertopic._topics import (
+    Images,
+    Keywords,
+    Label,
+    StructuredJSON,
+    Topic,
+    TopicHierarchy,
+    TopicMapping,
+    Topics,
+    TopicType,
+)
 
 
 def build_topics(counts: dict[int, int], probabilities: np.ndarray | None = None) -> Topics:
@@ -403,6 +413,42 @@ def test_mapping_rejects_an_incomplete_new_mapping():
 # --------------------------------------------------------------------------------------
 
 
+def test_keywords_carry_their_own_scores():
+    """Keywords are the one representation that ranks the words within a topic."""
+    keywords = Keywords(data=[("cat", 0.8), ("dog", 0.4)])
+
+    assert keywords.words == ["cat", "dog"]
+    assert keywords.scores == [0.8, 0.4]
+    assert keywords.word_scores == [("cat", 0.8), ("dog", 0.4)]
+
+
+@pytest.mark.parametrize(
+    "representation,expected_words",
+    [
+        (Label(data="animals"), ["animals"]),
+        (StructuredJSON(data={"topic": "animals", "theme": "pets"}), ["animals", "pets"]),
+        (Images(data="collage", captions=["a cat", "a dog"]), ["a cat", "a dog"]),
+    ],
+)
+def test_representations_without_scores_weight_every_word_equally(representation, expected_words):
+    """`words` reads any representation as text, and `scores` is what ranks those words.
+
+    Only keywords rank them. Everything else names the topic, so each word counts the same
+    and `word_scores` is what `get_topic` hands back.
+    """
+    assert representation.words == expected_words
+    assert representation.scores == [1.0] * len(expected_words)
+    assert representation.word_scores == [(word, 1.0) for word in expected_words]
+
+
+def test_a_representation_with_no_text_view_has_no_scores():
+    """Scores follow words, so a payload with no text view yields neither."""
+    images = Images(data="collage")
+
+    assert images.words == []
+    assert images.word_scores == []
+
+
 def test_images_have_no_words_until_they_are_captioned():
     """A representation may hold a modality that has no text view yet."""
     images = Images(data="collage")