diff --git a/app/assets/main.css b/app/assets/main.css
index bce110f018..56e50038b1 100644
--- a/app/assets/main.css
+++ b/app/assets/main.css
@@ -401,3 +401,55 @@ html:has(dialog:modal) {
 .vue-ui-pen-and-paper-group-actions {
   background-color: transparent !important;
 }
+
+/* Like button heart, shared by package and collection likes */
+@keyframes heart-spring {
+  0% {
+    transform: scale(1);
+  }
+  15% {
+    transform: scale(0.78);
+  }
+  45% {
+    transform: scale(1.55);
+  }
+  65% {
+    transform: scale(0.93);
+  }
+  80% {
+    transform: scale(1.1);
+  }
+  100% {
+    transform: scale(1);
+  }
+}
+
+@keyframes heart-unlike {
+  0% {
+    transform: scale(1);
+  }
+  30% {
+    transform: scale(0.85);
+  }
+  60% {
+    transform: scale(1.05);
+  }
+  100% {
+    transform: scale(1);
+  }
+}
+
+@media (prefers-reduced-motion: reduce) {
+  @keyframes heart-spring {
+    from,
+    to {
+      transform: scale(1);
+    }
+  }
+  @keyframes heart-unlike {
+    from,
+    to {
+      transform: scale(1);
+    }
+  }
+}
diff --git a/app/components/Collection/FollowButton.vue b/app/components/Collection/FollowButton.vue
new file mode 100644
index 0000000000..1d08b3a355
--- /dev/null
+++ b/app/components/Collection/FollowButton.vue
@@ -0,0 +1,37 @@
+<script setup lang="ts">
+import type { ReactionState } from '#shared/types/social'
+
+const props = defineProps<{
+  identifier: string
+  rkey: string
+}>()
+
+const follows = defineModel<ReactionState>({ required: true })
+const { toggle } = useCollectionReaction(follows, 'follow', () => props)
+
+const compactNumberFormatter = useCompactNumberFormatter()
+const label = computed(() =>
+  follows.value.viewerHas ? $t('collections.unfollow_label') : $t('collections.follow_label'),
+)
+
+// For the page's command palette entries
+defineExpose({ toggle })
+</script>
+
+<template>
+  <!-- No aria-pressed: the visible label already changes between Follow and Following -->
+  <TooltipApp :text="label" position="bottom" strategy="fixed">
+    <ButtonBase
+      :classicon="follows.viewerHas ? 'i-lucide:bell-ring' : 'i-lucide:bell-plus'"
+      @click="toggle"
+    >
+      {{ follows.viewerHas ? $t('collections.following') : $t('collections.follow') }}
+      <span class="text-fg-muted" aria-hidden="true">
+        {{ compactNumberFormatter.format(follows.total) }}
+      </span>
+      <span class="sr-only">
+        {{ $t('collections.followers', { count: $n(follows.total) }, follows.total) }}
+      </span>
+    </ButtonBase>
+  </TooltipApp>
+</template>
diff --git a/app/components/Collection/LikeButton.vue b/app/components/Collection/LikeButton.vue
new file mode 100644
index 0000000000..5561826618
--- /dev/null
+++ b/app/components/Collection/LikeButton.vue
@@ -0,0 +1,57 @@
+<script setup lang="ts">
+import type { ReactionState } from '#shared/types/social'
+
+const props = defineProps<{
+  identifier: string
+  rkey: string
+}>()
+
+const likes = defineModel<ReactionState>({ required: true })
+const { toggle: toggleLike } = useCollectionReaction(likes, 'like', () => props)
+
+const compactNumberFormatter = useCompactNumberFormatter()
+const prefersReducedMotion = useMediaQuery('(prefers-reduced-motion: reduce)')
+// Bumped per click so the heart animates again; 0 means no animation on first render
+const animKey = shallowRef(0)
+const heartAnimStyle = computed(() => {
+  if (animKey.value === 0 || prefersReducedMotion.value) return {}
+  return {
+    animation: likes.value.viewerHas
+      ? 'heart-spring 0.55s cubic-bezier(0.34,1.56,0.64,1) forwards'
+      : 'heart-unlike 0.3s ease forwards',
+  }
+})
+
+const label = computed(() =>
+  likes.value.viewerHas ? $t('collections.unlike') : $t('collections.like'),
+)
+
+async function toggle() {
+  animKey.value++
+  await toggleLike()
+}
+
+// For the page's command palette entries
+defineExpose({ toggle })
+</script>
+
+<template>
+  <!-- No aria-pressed: the label already changes between Like and Unlike -->
+  <TooltipApp :text="label" position="bottom" strategy="fixed">
+    <ButtonBase @click="toggle">
+      <span
+        :key="animKey"
+        :class="
+          likes.viewerHas ? 'i-lucide:heart-minus fill-red-500 text-red-500' : 'i-lucide:heart-plus'
+        "
+        :style="heartAnimStyle"
+        class="inline-block size-4"
+        aria-hidden="true"
+      />
+      <span aria-hidden="true">{{ compactNumberFormatter.format(likes.total) }}</span>
+      <span class="sr-only">
+        {{ label }}, {{ $t('collections.like_count', { count: $n(likes.total) }, likes.total) }}
+      </span>
+    </ButtonBase>
+  </TooltipApp>
+</template>
diff --git a/app/components/Package/Likes.vue b/app/components/Package/Likes.vue
index e48f543e62..371886775f 100644
--- a/app/components/Package/Likes.vue
+++ b/app/components/Package/Likes.vue
@@ -251,56 +251,3 @@ const likeAction = async () => {
   }
 }
 </style>
-
-<style>
-@keyframes heart-spring {
-  0% {
-    transform: scale(1);
-  }
-  15% {
-    transform: scale(0.78);
-  }
-  45% {
-    transform: scale(1.55);
-  }
-  65% {
-    transform: scale(0.93);
-  }
-  80% {
-    transform: scale(1.1);
-  }
-  100% {
-    transform: scale(1);
-  }
-}
-
-@keyframes heart-unlike {
-  0% {
-    transform: scale(1);
-  }
-  30% {
-    transform: scale(0.85);
-  }
-  60% {
-    transform: scale(1.05);
-  }
-  100% {
-    transform: scale(1);
-  }
-}
-
-@media (prefers-reduced-motion: reduce) {
-  @keyframes heart-spring {
-    from,
-    to {
-      transform: scale(1);
-    }
-  }
-  @keyframes heart-unlike {
-    from,
-    to {
-      transform: scale(1);
-    }
-  }
-}
-</style>
diff --git a/app/composables/useCollectionReaction.ts b/app/composables/useCollectionReaction.ts
new file mode 100644
index 0000000000..a9ce406bcd
--- /dev/null
+++ b/app/composables/useCollectionReaction.ts
@@ -0,0 +1,46 @@
+import type { Ref } from 'vue'
+import type { ReactionState } from '#shared/types/social'
+import { toggleCollectionReaction, type Reaction } from '~/utils/atproto/collections'
+
+/** Optimistic like or follow toggle for a collection; opens sign-in when signed out. */
+export function useCollectionReaction(
+  state: Ref<ReactionState>,
+  reaction: Reaction,
+  target: () => { identifier: string; rkey: string },
+) {
+  const { user } = useAtproto()
+  const authModal = useModal('auth-modal')
+  const isPending = shallowRef(false)
+
+  async function toggle() {
+    const handle = user.value?.handle
+    if (handle == null) {
+      authModal.open()
+      return
+    }
+    if (isPending.value) return
+
+    const previous = state.value
+    state.value = {
+      total: previous.total + (previous.viewerHas ? -1 : 1),
+      viewerHas: !previous.viewerHas,
+    }
+    isPending.value = true
+    try {
+      const { identifier, rkey } = target()
+      state.value = await toggleCollectionReaction(
+        identifier,
+        rkey,
+        reaction,
+        previous.viewerHas,
+        handle,
+      )
+    } catch {
+      state.value = previous
+    } finally {
+      isPending.value = false
+    }
+  }
+
+  return { toggle }
+}
diff --git a/app/pages/collections/[identifier]/[rkey].stories.ts b/app/pages/collections/[identifier]/[rkey].stories.ts
index ea8b0976b0..7a328bec42 100644
--- a/app/pages/collections/[identifier]/[rkey].stories.ts
+++ b/app/pages/collections/[identifier]/[rkey].stories.ts
@@ -4,6 +4,8 @@ import { pageDecorator } from '../../../../.storybook/decorators'
 import {
   mockCollectionHandle,
   mockCollectionHandler,
+  mockCollectionFollowHandlers,
+  mockCollectionLikeHandlers,
   mockCollectionRkey,
   mockPackageCardHandlers,
 } from '../../../storybook/mocks/handlers/collections'
@@ -17,7 +19,13 @@ const meta = {
     `/collections/${mockCollectionHandle}/${mockCollectionRkey}`,
   ),
   beforeEach({ msw }) {
-    msw.use(mockCollectionHandler, ...mockPackageCardHandlers, mockAuthSessionHandler())
+    msw.use(
+      mockCollectionHandler,
+      ...mockPackageCardHandlers,
+      ...mockCollectionLikeHandlers,
+      ...mockCollectionFollowHandlers,
+      mockAuthSessionHandler(),
+    )
   },
   parameters: { layout: 'fullscreen' },
   decorators: [pageDecorator],
diff --git a/app/pages/collections/[identifier]/[rkey].vue b/app/pages/collections/[identifier]/[rkey].vue
index 8c24691d2b..36be808ef2 100644
--- a/app/pages/collections/[identifier]/[rkey].vue
+++ b/app/pages/collections/[identifier]/[rkey].vue
@@ -1,5 +1,5 @@
 <script setup lang="ts">
-import type { CollectionView } from '#shared/types/social'
+import type { CollectionView, ReactionState } from '#shared/types/social'
 import type { CommandPaletteContextCommandInput } from '~/types/command-palette'
 import {
   collectionPath,
@@ -39,6 +39,17 @@ const { data: packageCards } = usePackagesByName(packageNames)
 const { user } = useAtproto()
 const isOwner = computed(() => !!user.value?.did && user.value.did === collection.value?.did)
 
+// useFetch data is a shallow ref, so replace rather than mutate
+const reactionModel = (key: 'likes' | 'follows') =>
+  computed<ReactionState>({
+    get: () => collection.value?.[key] ?? { total: 0, viewerHas: false },
+    set: value => {
+      if (collection.value) collection.value = { ...collection.value, [key]: value }
+    },
+  })
+const likes = reactionModel('likes')
+const follows = reactionModel('follows')
+
 const { polite } = useAnnouncer()
 const { close: closeCommandPalette } = useCommandPalette()
 const editor = useTemplateRef('editor')
@@ -112,6 +123,9 @@ const duplicateRoute = computed(() => ({
   query: { from: `${collection.value?.did}/${collection.value?.rkey}` },
 }))
 
+const { announce } = useCommandPalette()
+const likeButton = useTemplateRef('likeButton')
+const followButton = useTemplateRef('followButton')
 useCommandPaletteContextCommands(
   computed((): CommandPaletteContextCommandInput[] => {
     const current = collection.value
@@ -119,14 +133,54 @@ useCommandPaletteContextCommands(
     const keywords = [current.name, current.handle]
     const commands: CommandPaletteContextCommandInput[] = [
       {
-        id: 'collection-duplicate',
+        id: 'collection-like',
         group: 'actions',
-        label: $t('collections.duplicate'),
+        label: current.likes.viewerHas ? $t('collections.unlike') : $t('collections.like'),
         keywords,
-        iconClass: 'i-lucide:copy',
-        to: duplicateRoute.value,
+        iconClass: current.likes.viewerHas ? 'i-lucide:heart-minus' : 'i-lucide:heart-plus',
+        action: async () => {
+          const before = likes.value.viewerHas
+          await likeButton.value?.toggle()
+          // Unchanged when signed out (the sign-in dialog opened instead) or when it failed
+          if (likes.value.viewerHas === before) return
+          announce(
+            before
+              ? $t('collections.reaction_announcements.unliked')
+              : $t('collections.reaction_announcements.liked'),
+          )
+        },
       },
     ]
+    if (!isOwner.value) {
+      commands.push({
+        id: 'collection-follow',
+        group: 'actions',
+        label: current.follows.viewerHas
+          ? $t('collections.unfollow_label')
+          : $t('collections.follow_label'),
+        keywords,
+        iconClass: current.follows.viewerHas ? 'i-lucide:bell-ring' : 'i-lucide:bell-plus',
+        action: async () => {
+          const before = follows.value.viewerHas
+          await followButton.value?.toggle()
+          // Unchanged when signed out (the sign-in dialog opened instead) or when it failed
+          if (follows.value.viewerHas === before) return
+          announce(
+            before
+              ? $t('collections.reaction_announcements.unfollowed')
+              : $t('collections.reaction_announcements.followed'),
+          )
+        },
+      })
+    }
+    commands.push({
+      id: 'collection-duplicate',
+      group: 'actions',
+      label: $t('collections.duplicate'),
+      keywords,
+      iconClass: 'i-lucide:copy',
+      to: duplicateRoute.value,
+    })
     if (isOwner.value && !isEditing.value) {
       commands.push(
         {
@@ -197,6 +251,20 @@ defineOgImage(
       <p v-if="collection.description" class="text-fg-muted">{{ collection.description }}</p>
 
       <div class="flex flex-wrap items-center gap-3">
+        <CollectionLikeButton
+          ref="likeButton"
+          v-model="likes"
+          :identifier="collection.did"
+          :rkey="collection.rkey"
+        />
+        <!-- Owners follow their own collections implicitly -->
+        <CollectionFollowButton
+          v-if="!isOwner"
+          ref="followButton"
+          v-model="follows"
+          :identifier="collection.did"
+          :rkey="collection.rkey"
+        />
         <LinkBase variant="button-secondary" classicon="i-lucide:copy" :to="duplicateRoute">
           {{ $t('collections.duplicate') }}
         </LinkBase>
diff --git a/app/pages/profile/[identity]/index.vue b/app/pages/profile/[identity]/index.vue
index 0b3de9f82f..1c1f18cca4 100644
--- a/app/pages/profile/[identity]/index.vue
+++ b/app/pages/profile/[identity]/index.vue
@@ -2,7 +2,7 @@
 import { useInfiniteScroll } from '@vueuse/core'
 import { updateProfile as updateProfileUtil } from '~/utils/atproto/profile'
 import { fetchProfileLikes } from '~/utils/atproto/likes'
-import { fetchUserCollections } from '~/utils/atproto/collections'
+import { fetchFollowedCollections, fetchUserCollections } from '~/utils/atproto/collections'
 import type { CommandPaletteContextCommandInput } from '~/types/command-palette'
 import { getSafeHttpUrl } from '#shared/utils/url'
 
@@ -87,7 +87,13 @@ const isOwnProfile = computed(
 )
 
 const collections = usePagedCollections(cursor => fetchUserCollections(identity.value, cursor, 12))
-onMounted(() => collections.load())
+const following = usePagedCollections(cursor =>
+  fetchFollowedCollections(identity.value, cursor, 12),
+)
+onMounted(() => {
+  collections.load()
+  following.load()
+})
 
 const allLikesRecords = ref<string[]>([])
 // undefined = not yet fetched, string = next page cursor, null = no more pages
@@ -300,6 +306,34 @@ defineOgImage(
       />
     </section>
 
+    <section
+      v-if="
+        following.items.value.length > 0 ||
+        isOwnProfile ||
+        following.isLoading.value ||
+        following.error.value
+      "
+      class="flex flex-col gap-8 mb-12"
+      aria-labelledby="profile-following-heading"
+    >
+      <h2
+        id="profile-following-heading"
+        class="font-mono text-2xl sm:text-3xl font-medium min-w-0 break-words"
+      >
+        {{ $t('profile.following_collections') }}
+      </h2>
+      <CollectionGrid
+        :items="following.items.value"
+        :pending="following.isLoading.value"
+        :loading-more="following.isLoading.value"
+        :error="following.error.value"
+        :has-more="following.hasMore.value"
+        :empty-text="$t('profile.no_following_collections')"
+        :skeletons="3"
+        @load-more="following.load"
+      />
+    </section>
+
     <section class="flex flex-col gap-8">
       <h2
         class="font-mono text-2xl sm:text-3xl font-medium min-w-0 break-words"
diff --git a/app/storybook/mocks/handlers/collections.ts b/app/storybook/mocks/handlers/collections.ts
index 76ffcc9f2f..9af3de28d1 100644
--- a/app/storybook/mocks/handlers/collections.ts
+++ b/app/storybook/mocks/handlers/collections.ts
@@ -40,6 +40,8 @@ export const mockPackageCards = new Map(
 
 export const mockCollection: CollectionView = {
   ...mockCollectionSummary,
+  likes: { total: 12, viewerHas: false },
+  follows: { total: 5, viewerHas: false },
   items: [
     {
       kind: 'package',
@@ -95,3 +97,21 @@ export const mockPackageCardHandlers = [
     } satisfies PackageMetaResponse)
   }),
 ]
+
+export const mockCollectionLikeHandlers = [
+  http.post(`/api/social/collections/:identifier/:rkey/like`, () =>
+    HttpResponse.json({ total: mockCollection.likes.total + 1, viewerHas: true }),
+  ),
+  http.delete(`/api/social/collections/:identifier/:rkey/like`, () =>
+    HttpResponse.json({ total: mockCollection.likes.total, viewerHas: false }),
+  ),
+]
+
+export const mockCollectionFollowHandlers = [
+  http.post(`/api/social/collections/:identifier/:rkey/follow`, () =>
+    HttpResponse.json({ total: mockCollection.follows.total + 1, viewerHas: true }),
+  ),
+  http.delete(`/api/social/collections/:identifier/:rkey/follow`, () =>
+    HttpResponse.json({ total: mockCollection.follows.total, viewerHas: false }),
+  ),
+]
diff --git a/app/utils/atproto/collections.ts b/app/utils/atproto/collections.ts
index a84ce16aea..70232ee41c 100644
--- a/app/utils/atproto/collections.ts
+++ b/app/utils/atproto/collections.ts
@@ -1,7 +1,7 @@
 import { FetchError } from 'ofetch'
 import type { InferInput } from 'valibot'
 import type { CollectionBodySchema } from '#shared/schemas/social'
-import type { CollectionSummary, OwnCollection } from '#shared/types/social'
+import type { CollectionSummary, OwnCollection, ReactionState } from '#shared/types/social'
 import { authRedirect, handleAuthError } from '~/utils/atproto/helpers'
 
 export type CollectionBody = InferInput<typeof CollectionBodySchema>
@@ -75,6 +75,32 @@ export function deleteCollection(identifier: string, rkey: string, userHandle?:
   )
 }
 
+export type Reaction = 'like' | 'follow'
+
+export function toggleCollectionReaction(
+  identifier: string,
+  rkey: string,
+  reaction: Reaction,
+  currentlyOn: boolean,
+  userHandle?: string | null,
+) {
+  return request(
+    () =>
+      $fetch<ReactionState>(`${collectionPath(identifier, rkey)}/${reaction}`, {
+        method: currentlyOn ? 'DELETE' : 'POST',
+      }),
+    userHandle,
+  )
+}
+
+/** Collections the account follows, newest follow first. */
+export function fetchFollowedCollections(identifier: string, cursor?: string | null, limit = 20) {
+  return $fetch<{ cursor?: string; items: CollectionSummary[] }>(
+    `/api/social/profile/${encodeURIComponent(identifier)}/followed-collections`,
+    { query: { cursor: cursor ?? undefined, limit } },
+  )
+}
+
 export function fetchOwnCollections() {
   return $fetch<OwnCollection[]>('/api/social/collections/mine')
 }
diff --git a/docs/content/2.guide/1.features.md b/docs/content/2.guide/1.features.md
index e1d24e4874..45712670a6 100644
--- a/docs/content/2.guide/1.features.md
+++ b/docs/content/2.guide/1.features.md
@@ -107,11 +107,12 @@ Collections are curated, ordered lists of npm packages, with an optional note on
 - **Create and edit** - Name a collection, describe it, and add, reorder, annotate, or remove up to 1,000 items
 - **Include other collections** - Add a collection's link to another collection to show it as a linked entry with its author and size
 - **Duplicate** - Start a new collection from a copy of any collection
+- **Like and follow** - Like a collection to recommend it, or follow it to keep up with it. Your own collections count as followed
 
 ## Explore users and organizations
 
 - **User profiles** - View any npm user's public packages at `/~username`
-- **Profile collections** - See the collections an npmx social profile has made
+- **Profile collections** - See the collections an npmx social profile has made and the ones it follows
 - **Profile likes** - View packages liked by npmx social profiles
 - **Organization pages** - Browse org packages at `/@orgname`
 - **Search and filter** - Find packages within user/org lists
@@ -121,6 +122,7 @@ Collections are curated, ordered lists of npm packages, with an optional note on
 ## Use community signals
 
 - **Package likes** - Like packages with an npmx social profile
+- **Collection likes and follows** - Like and follow collections
 - **Likes leaderboard** - Browse the most-liked packages across npmx
 
 ## Access related resources
diff --git a/docs/content/2.guide/2.keyboard-shortcuts.md b/docs/content/2.guide/2.keyboard-shortcuts.md
index cb27aa44dd..ddc9e62571 100644
--- a/docs/content/2.guide/2.keyboard-shortcuts.md
+++ b/docs/content/2.guide/2.keyboard-shortcuts.md
@@ -15,7 +15,7 @@ The command palette lets you:
 
 - Jump between major pages like home, compare, settings, and docs
 - Open package-specific surfaces like the main page, docs, code, and diff views
-- Find your own collections by name, and edit or duplicate the collection you're viewing
+- Find your own collections by name, and like, follow, edit or duplicate the collection you're viewing
 - Switch settings such as language, accent color, and background theme
 - Open external resources like docs, chat, source, and package links
 
diff --git a/docs/content/4.integrations/2.collections.md b/docs/content/4.integrations/2.collections.md
index 95601de9ae..b98250996f 100644
--- a/docs/content/4.integrations/2.collections.md
+++ b/docs/content/4.integrations/2.collections.md
@@ -122,3 +122,4 @@ To edit a collection, use `com.atproto.repo.putRecord` with the same record key,
 ## When it shows up
 
 - **Your profile** reads straight from your PDS, so it updates right away. **The collection page** does too for changes made on npmx.dev; changes from other apps can take up to 5 minutes.
+- **Like counts** come from [Constellation](https://constellation.microcosm.blue/), usually within seconds.
diff --git a/i18n/locales/en.json b/i18n/locales/en.json
index 9619ee82f1..58c871a649 100644
--- a/i18n/locales/en.json
+++ b/i18n/locales/en.json
@@ -460,7 +460,9 @@
       "share_button": "Share on Bluesky",
       "compose_text": "Hey {'@'}{handle}! Have you checked out npmx.dev yet? It's a browser for the npm registry that's fast, modern, and open-source.\nhttps://npmx.dev"
     },
-    "collections": "Collections"
+    "collections": "Collections",
+    "following_collections": "Followed collections",
+    "no_following_collections": "You're not following any collections yet."
   },
   "collections": {
     "title": "Collections",
@@ -473,6 +475,8 @@
     "empty_collection": "This collection is empty.",
     "by": "by {'@'}{handle}",
     "item_count": "{count} item | {count} items",
+    "like": "Like this collection",
+    "unlike": "Unlike this collection",
     "duplicate": "Duplicate",
     "delete_title": "Delete this collection?",
     "delete_body": "This can't be undone.",
@@ -514,6 +518,18 @@
       "too_many_items": "Remove {count} item. A collection holds up to {max}. | Remove {count} items. A collection holds up to {max}.",
       "too_long": "Shorten the text. The name can be up to {name} characters, the description {description} and each note {note}."
     },
+    "follow": "Follow",
+    "following": "Following",
+    "follow_label": "Follow this collection",
+    "unfollow_label": "Unfollow this collection",
+    "followers": "{count} follower | {count} followers",
+    "like_count": "{count} like | {count} likes",
+    "reaction_announcements": {
+      "liked": "You like this collection.",
+      "unliked": "You no longer like this collection.",
+      "followed": "You follow this collection.",
+      "unfollowed": "You no longer follow this collection."
+    },
     "your_data": {
       "summary": "It's your data",
       "body": "Collections live in your Atmosphere account, not on npmx. They're open, public data on the {atproto}: create, view and change them here, in any other app, or with your own scripts, and take them wherever you go. Have fun with it!",
diff --git a/i18n/locales/fr-FR.json b/i18n/locales/fr-FR.json
index f3d18f7033..16d8b40e89 100644
--- a/i18n/locales/fr-FR.json
+++ b/i18n/locales/fr-FR.json
@@ -366,7 +366,9 @@
       "share_button": "Partager sur Bluesky",
       "compose_text": "Salut {'@'}{handle} ! As-tu déjà testé npmx.dev ? C'est un navigateur pour le registre npm : rapide, moderne et open source.\nhttps://npmx.dev"
     },
-    "collections": "Collections"
+    "collections": "Collections",
+    "following_collections": "Collections suivies",
+    "no_following_collections": "Vous ne suivez encore aucune collection."
   },
   "collections": {
     "title": "Collections",
@@ -379,6 +381,8 @@
     "empty_collection": "Cette collection est vide.",
     "by": "par {'@'}{handle}",
     "item_count": "{count} élément | {count} éléments",
+    "like": "Aimer cette collection",
+    "unlike": "Ne plus aimer cette collection",
     "duplicate": "Dupliquer",
     "delete_title": "Supprimer cette collection ?",
     "delete_body": "Cette action est irréversible.",
@@ -420,6 +424,18 @@
       "too_many_items": "Retirez {count} élément. Une collection en contient au maximum {max}. | Retirez {count} éléments. Une collection en contient au maximum {max}.",
       "too_long": "Raccourcissez le texte. Le nom peut compter jusqu'à {name} caractères, la description {description} et chaque note {note}."
     },
+    "follow": "Suivre",
+    "following": "Suivie",
+    "follow_label": "Suivre cette collection",
+    "unfollow_label": "Ne plus suivre cette collection",
+    "followers": "{count} abonné | {count} abonnés",
+    "like_count": "{count} j'aime | {count} j'aime",
+    "reaction_announcements": {
+      "liked": "Vous aimez cette collection.",
+      "unliked": "Vous n'aimez plus cette collection.",
+      "followed": "Vous suivez cette collection.",
+      "unfollowed": "Vous ne suivez plus cette collection."
+    },
     "your_data": {
       "summary": "Ce sont vos données",
       "body": "Les collections sont stockées dans votre compte Atmosphere, pas chez npmx. Ce sont des données ouvertes et publiques sur l'{atproto} : créez-les, consultez-les et modifiez-les ici, dans n'importe quelle autre application ou avec vos propres scripts, et emportez-les où vous voulez. Amusez-vous bien !",
diff --git a/i18n/schema.json b/i18n/schema.json
index 4c395a03c9..9d7d991039 100644
--- a/i18n/schema.json
+++ b/i18n/schema.json
@@ -1386,6 +1386,12 @@
         },
         "collections": {
           "type": "string"
+        },
+        "following_collections": {
+          "type": "string"
+        },
+        "no_following_collections": {
+          "type": "string"
         }
       },
       "additionalProperties": false
@@ -1423,6 +1429,12 @@
         "item_count": {
           "type": "string"
         },
+        "like": {
+          "type": "string"
+        },
+        "unlike": {
+          "type": "string"
+        },
         "duplicate": {
           "type": "string"
         },
@@ -1546,6 +1558,42 @@
           },
           "additionalProperties": false
         },
+        "follow": {
+          "type": "string"
+        },
+        "following": {
+          "type": "string"
+        },
+        "follow_label": {
+          "type": "string"
+        },
+        "unfollow_label": {
+          "type": "string"
+        },
+        "followers": {
+          "type": "string"
+        },
+        "like_count": {
+          "type": "string"
+        },
+        "reaction_announcements": {
+          "type": "object",
+          "properties": {
+            "liked": {
+              "type": "string"
+            },
+            "unliked": {
+              "type": "string"
+            },
+            "followed": {
+              "type": "string"
+            },
+            "unfollowed": {
+              "type": "string"
+            }
+          },
+          "additionalProperties": false
+        },
         "your_data": {
           "type": "object",
           "properties": {
diff --git a/server/api/social/collections/[identifier]/[rkey].get.ts b/server/api/social/collections/[identifier]/[rkey].get.ts
index 213b329309..99c1f1e5c7 100644
--- a/server/api/social/collections/[identifier]/[rkey].get.ts
+++ b/server/api/social/collections/[identifier]/[rkey].get.ts
@@ -1,14 +1,18 @@
 /**
  * GET /api/social/collections/:identifier/:rkey
  *
- * A collection with its items resolved.
+ * A collection with its items resolved, plus like and included-in counts.
  */
-export default defineEventHandler(async event => {
+export default eventHandlerWithOAuthSession(async (event, oAuthSession) => {
   const { identifier, rkey } = getCollectionRouteParams(event)
 
   let collection
   try {
-    collection = await new CollectionsUtils().getCollection(identifier, rkey)
+    collection = await new CollectionsUtils().getCollection(
+      identifier,
+      rkey,
+      oAuthSession?.did.toString(),
+    )
   } catch (error: unknown) {
     handleApiError(error, { statusCode: 502, message: 'Failed to get collection' })
   }
diff --git a/server/api/social/collections/[identifier]/[rkey]/follow.delete.ts b/server/api/social/collections/[identifier]/[rkey]/follow.delete.ts
new file mode 100644
index 0000000000..fee72b4f68
--- /dev/null
+++ b/server/api/social/collections/[identifier]/[rkey]/follow.delete.ts
@@ -0,0 +1,6 @@
+/**
+ * DELETE /api/social/collections/:identifier/:rkey/follow
+ */
+export default eventHandlerWithOAuthSession((event, session) =>
+  setReaction(session, getCollectionRouteParams(event), 'follow', false),
+)
diff --git a/server/api/social/collections/[identifier]/[rkey]/follow.post.ts b/server/api/social/collections/[identifier]/[rkey]/follow.post.ts
new file mode 100644
index 0000000000..6f345dee4b
--- /dev/null
+++ b/server/api/social/collections/[identifier]/[rkey]/follow.post.ts
@@ -0,0 +1,6 @@
+/**
+ * POST /api/social/collections/:identifier/:rkey/follow
+ */
+export default eventHandlerWithOAuthSession((event, session) =>
+  setReaction(session, getCollectionRouteParams(event), 'follow', true),
+)
diff --git a/server/api/social/collections/[identifier]/[rkey]/like.delete.ts b/server/api/social/collections/[identifier]/[rkey]/like.delete.ts
new file mode 100644
index 0000000000..8a6d56f372
--- /dev/null
+++ b/server/api/social/collections/[identifier]/[rkey]/like.delete.ts
@@ -0,0 +1,6 @@
+/**
+ * DELETE /api/social/collections/:identifier/:rkey/like
+ */
+export default eventHandlerWithOAuthSession((event, session) =>
+  setReaction(session, getCollectionRouteParams(event), 'like', false),
+)
diff --git a/server/api/social/collections/[identifier]/[rkey]/like.post.ts b/server/api/social/collections/[identifier]/[rkey]/like.post.ts
new file mode 100644
index 0000000000..11650c407e
--- /dev/null
+++ b/server/api/social/collections/[identifier]/[rkey]/like.post.ts
@@ -0,0 +1,6 @@
+/**
+ * POST /api/social/collections/:identifier/:rkey/like
+ */
+export default eventHandlerWithOAuthSession((event, session) =>
+  setReaction(session, getCollectionRouteParams(event), 'like', true),
+)
diff --git a/server/api/social/profile/[identifier]/followed-collections.get.ts b/server/api/social/profile/[identifier]/followed-collections.get.ts
new file mode 100644
index 0000000000..10a43617ae
--- /dev/null
+++ b/server/api/social/profile/[identifier]/followed-collections.get.ts
@@ -0,0 +1,16 @@
+/**
+ * GET /api/social/profile/:identifier/followed-collections
+ *
+ * Collections the account follows, newest follow first, from its PDS. A page can come back
+ * shorter than `limit` when followed collections were deleted or hidden.
+ */
+export default defineEventHandler(async event => {
+  const identifier = getRouterParam(event, 'identifier')!
+  const { cursor, limit } = getPaginationQuery(event)
+
+  try {
+    return await new CollectionsUtils().listFollowedCollections(identifier, limit, cursor)
+  } catch (error: unknown) {
+    handleApiError(error, { statusCode: 502, message: 'Failed to list followed collections' })
+  }
+})
diff --git a/server/utils/atproto/oauth.ts b/server/utils/atproto/oauth.ts
index f97d8a58ac..97f5d0cb61 100644
--- a/server/utils/atproto/oauth.ts
+++ b/server/utils/atproto/oauth.ts
@@ -9,13 +9,18 @@ import type { EventHandlerRequest, H3Event, SessionManager } from 'h3'
 import { NodeOAuthClient, AtprotoDohHandleResolver } from '@atproto/oauth-client-node'
 import { getOAuthLock } from '#server/utils/atproto/lock'
 import { useOAuthStorage } from '#server/utils/atproto/storage'
-import { COLLECTIONS_SCOPE, LIKES_SCOPE, PROFILE_SCOPE } from '#shared/utils/constants'
+import {
+  COLLECTIONS_SCOPE,
+  FOLLOWS_SCOPE,
+  LIKES_SCOPE,
+  PROFILE_SCOPE,
+} from '#shared/utils/constants'
 import type { UserServerSession } from '#shared/types/userSession'
 // @ts-expect-error virtual file from oauth module
 import { clientUri } from '#oauth/config'
 
 // TODO: If you add writing a new record you will need to add a scope for it
-export const scope = `atproto ${LIKES_SCOPE} ${PROFILE_SCOPE} ${COLLECTIONS_SCOPE}`
+export const scope = `atproto ${LIKES_SCOPE} ${PROFILE_SCOPE} ${COLLECTIONS_SCOPE} ${FOLLOWS_SCOPE}`
 
 /**
  * Resolves a did to a handle via DoH or via the http website calls
diff --git a/server/utils/atproto/utils/collection-writes.ts b/server/utils/atproto/utils/collection-writes.ts
index 0737f04453..7d03b1f895 100644
--- a/server/utils/atproto/utils/collection-writes.ts
+++ b/server/utils/atproto/utils/collection-writes.ts
@@ -1,13 +1,25 @@
 import type { OAuthSession } from '@atproto/oauth-client-node'
 import type { InferOutput } from 'valibot'
-import { Client, isDatetimeString, toDatetimeString, type UriString } from '@atproto/lex'
+import {
+  Client,
+  isDatetimeString,
+  toDatetimeString,
+  type AtUriString,
+  type UriString,
+} from '@atproto/lex'
 import * as dev from '#shared/types/lexicons/dev'
 import type { CollectionBodySchema } from '#shared/schemas/social'
-import type { MiniDoc } from '#shared/types/social'
-import { COLLECTION_SUBJECT_REF, COLLECTIONS_SCOPE } from '#shared/utils/constants'
+import type { MiniDoc, ReactionState } from '#shared/types/social'
+import {
+  COLLECTION_SUBJECT_REF,
+  COLLECTIONS_SCOPE,
+  FOLLOWS_SCOPE,
+  LIKES_SCOPE,
+} from '#shared/utils/constants'
 import { throwOnMissingOAuthScope } from '#server/utils/atproto/oauth'
+import type { Reaction } from './collections'
 
-/** Writes to collections, as the signed-in user. */
+/** Writes to collections and their likes and follows, as the signed-in user. */
 
 type CollectionBody = InferOutput<typeof CollectionBodySchema>
 type CollectionRef = { identifier: string; rkey: string }
@@ -149,3 +161,45 @@ export async function deleteCollection(session: OAuthSession | undefined, ref: C
     .catch(error => console.error('[collections] Caching a delete failed', error))
   return { uri: COLLECTION_SUBJECT_REF(did, ref.rkey) }
 }
+
+const REACTION_SCOPES: Record<Reaction, string> = { like: LIKES_SCOPE, follow: FOLLOWS_SCOPE }
+
+/**
+ * Likes or follows (`on`) or un-likes or un-follows a collection.
+ * Idempotent: asking for the state the viewer is already in changes nothing.
+ */
+export async function setReaction(
+  session: OAuthSession | undefined,
+  ref: CollectionRef,
+  reaction: Reaction,
+  on: boolean,
+): Promise<ReactionState> {
+  const { client, did } = await getWriter(session, REACTION_SCOPES[reaction])
+  const owner = await resolveOwner(ref)
+  const uri = COLLECTION_SUBJECT_REF(owner.did, ref.rkey)
+  const utils = new CollectionsUtils()
+  const existing = await utils.getViewerReaction(reaction, uri, did)
+  if (Boolean(existing) === on) return await utils.getReaction(reaction, uri, did)
+  // Owners follow their own collections implicitly, and a record would inflate the count
+  if (on && reaction === 'follow' && owner.did === did) {
+    throw createError({ status: 400, message: 'You already follow your own collections' })
+  }
+  const totalBefore = await utils.getReactionTotal(reaction, uri)
+
+  if (!on) {
+    await (reaction === 'like'
+      ? client.delete(dev.npmx.feed.like, { rkey: existing!.rkey })
+      : client.delete(dev.npmx.graph.follow, { rkey: existing!.rkey }))
+    return await utils.recordUnreaction(reaction, uri, did, totalBefore)
+  }
+
+  if (!(await utils.getStoredRecord(owner, ref.rkey))) {
+    throw createError({ status: 404, message: 'Collection not found' })
+  }
+  const createdAt = toDatetimeString(new Date())
+  // A like's subjectRef, not its CID-pinned `subject`: collections change, likes shouldn't break.
+  const created = await (reaction === 'like'
+    ? client.create(dev.npmx.feed.like, { createdAt, subjectRef: uri as UriString })
+    : client.create(dev.npmx.graph.follow, { createdAt, subject: uri as AtUriString }))
+  return await utils.recordReaction(reaction, uri, did, created.uri.split('/').pop()!, totalBefore)
+}
diff --git a/server/utils/atproto/utils/collections.ts b/server/utils/atproto/utils/collections.ts
index 2b67bdc316..178f91b95f 100644
--- a/server/utils/atproto/utils/collections.ts
+++ b/server/utils/atproto/utils/collections.ts
@@ -8,16 +8,29 @@ import type {
   CollectionView,
   MiniDoc,
   OwnCollection,
+  ReactionState,
 } from '#shared/types/social'
 import { parseSubjectRef } from '#shared/utils/collections'
 import { mapWithConcurrency } from '#shared/utils/async'
 import { CACHE_MAX_AGE_ONE_MINUTE, COLLECTION_SUBJECT_REF } from '#shared/utils/constants'
+import type { Backlink, Constellation } from '#shared/utils/constellation'
 
 const HEADERS = { 'User-Agent': 'npmx' }
 const COLLECTION_NSID = dev.npmx.collection.$nsid
 
+// Records that point at a collection and are counted once per account.
+const REACTIONS = {
+  like: { nsid: dev.npmx.feed.like.$nsid, path: 'subjectRef' },
+  follow: { nsid: dev.npmx.graph.follow.$nsid, path: 'subject' },
+} as const
+export type Reaction = keyof typeof REACTIONS
+
 const CACHE_PREFIX = 'atproto-collections:'
 const CACHE_RECORD_KEY = (did: string, rkey: string) => `${CACHE_PREFIX}${did}:${rkey}:record`
+const CACHE_REACTION_TOTAL_KEY = (reaction: Reaction, uri: string) =>
+  `${CACHE_PREFIX}${uri}:${reaction}:total`
+const CACHE_VIEWER_REACTION_KEY = (reaction: Reaction, uri: string, did: string) =>
+  `${CACHE_PREFIX}${uri}:${reaction}:${did}`
 const CACHE_MAX_AGE = CACHE_MAX_AGE_ONE_MINUTE * 5
 
 // The owner's PDS is whatever their DID doc says, so it may be slow or hostile.
@@ -27,6 +40,7 @@ const RESOLVE_CONCURRENCY = 16
 export type StoredRecord = { uri: string; cid: string; value: dev.npmx.collection.Main }
 
 export type CollectionsDeps = {
+  constellation: Pick<Constellation, 'getBackLinks' | 'getLinksDistinctDids'>
   cache: CacheAdapter
   resolveIdentity: (identifier: string) => Promise<MiniDoc>
   /** Raw record from the owner's PDS, or null when it doesn't exist. Not yet validated. */
@@ -39,6 +53,12 @@ export type CollectionsDeps = {
     limit: number,
     cursor?: string,
   ) => Promise<{ cursor?: string; records: StoredRecord[] }>
+  /** The account's follow records, with subjects not yet validated. */
+  listFollows: (
+    miniDoc: MiniDoc,
+    limit: number,
+    cursor?: string,
+  ) => Promise<{ cursor?: string; records: { rkey: string; subject: string }[] }>
   packageExists: (packageName: string) => Promise<boolean>
 }
 
@@ -75,6 +95,8 @@ function toSummary(miniDoc: MiniDoc, rkey: string, stored: StoredRecord): Collec
 function defaultDeps(): CollectionsDeps {
   const identity = new IdentityUtils()
   return {
+    // CollectionsUtils caches what it needs
+    constellation: createUncachedConstellation(),
     cache: getCacheAdapter('generic'),
     resolveIdentity: identifier => identity.getMiniDoc(identifier) as Promise<MiniDoc>,
     fetchRecord: async (miniDoc, rkey) => {
@@ -114,6 +136,22 @@ function defaultDeps(): CollectionsDeps {
         }),
       }
     },
+    listFollows: async (miniDoc, limit, cursor) => {
+      const client = new Client(miniDoc.pds, { headers: HEADERS })
+      const result = await client.list(dev.npmx.graph.follow, {
+        repo: miniDoc.did as `did:${string}:${string}`,
+        limit,
+        cursor,
+        signal: AbortSignal.timeout(PDS_TIMEOUT_MS),
+      })
+      return {
+        cursor: result.cursor,
+        records: result.records.flatMap(record => {
+          const rkey = record.uri.split('/').pop()
+          return record.valid && rkey ? [{ rkey, subject: record.value.subject }] : []
+        }),
+      }
+    },
     packageExists: name => fetchNpmPackageExists(name),
   }
 }
@@ -165,17 +203,99 @@ export class CollectionsUtils {
     await this.setCached(CACHE_RECORD_KEY(did, rkey), record)
   }
 
-  async getCollection(identifier: string, rkey: string): Promise<CollectionView | null> {
+  async getCollection(
+    identifier: string,
+    rkey: string,
+    viewerDid?: string,
+  ): Promise<CollectionView | null> {
     const miniDoc = await this.deps.resolveIdentity(identifier)
     const stored = await this.getStoredRecord(miniDoc, rkey)
     if (!stored) return null
 
-    const items = await mapWithConcurrency(
-      stored.value.items,
-      item => this.resolveItem(item.subjectRef, item.note),
-      RESOLVE_CONCURRENCY,
-    )
-    return { ...toSummary(miniDoc, rkey, stored), items }
+    const [items, likes, follows] = await Promise.all([
+      mapWithConcurrency(
+        stored.value.items,
+        item => this.resolveItem(item.subjectRef, item.note),
+        RESOLVE_CONCURRENCY,
+      ),
+      this.getReaction('like', stored.uri, viewerDid),
+      this.getReaction('follow', stored.uri, viewerDid),
+    ])
+    return { ...toSummary(miniDoc, rkey, stored), items, likes, follows }
+  }
+
+  async getReaction(reaction: Reaction, uri: string, viewerDid?: string): Promise<ReactionState> {
+    const [total, viewerRecord] = await Promise.all([
+      this.getReactionTotal(reaction, uri),
+      viewerDid ? this.getViewerReaction(reaction, uri, viewerDid) : null,
+    ])
+    return { total, viewerHas: viewerRecord !== null }
+  }
+
+  getReactionTotal(reaction: Reaction, uri: string): Promise<number> {
+    const { nsid, path } = REACTIONS[reaction]
+    return this.cached(CACHE_REACTION_TOTAL_KEY(reaction, uri), async () => {
+      const { data } = await this.deps.constellation.getLinksDistinctDids(
+        uri,
+        nsid,
+        `.${path}`,
+        1,
+        undefined,
+        0,
+      )
+      return data.total
+    })
+  }
+
+  /** The viewer's like or follow record for a collection, or null. */
+  getViewerReaction(reaction: Reaction, uri: string, viewerDid: string): Promise<Backlink | null> {
+    const { nsid, path } = REACTIONS[reaction]
+    return this.cached(CACHE_VIEWER_REACTION_KEY(reaction, uri, viewerDid), async () => {
+      const { data } = await this.deps.constellation.getBackLinks(
+        uri,
+        nsid,
+        path,
+        1,
+        undefined,
+        false,
+        [[viewerDid]],
+        0,
+      )
+      return data.records[0] ?? null
+    })
+  }
+
+  // Constellation takes a few seconds to see a new record, so writes update the cache directly,
+  // as PackageLikesUtils does for packages. `totalBefore` must be read before the PDS write, or a
+  // refresh that already saw it would be counted twice.
+  async recordReaction(
+    reaction: Reaction,
+    uri: string,
+    viewerDid: string,
+    rkey: string,
+    totalBefore: number,
+  ): Promise<ReactionState> {
+    const backlink: Backlink = { did: viewerDid, collection: REACTIONS[reaction].nsid, rkey }
+    const total = totalBefore + 1
+    await Promise.all([
+      this.setCached(CACHE_VIEWER_REACTION_KEY(reaction, uri, viewerDid), backlink),
+      this.setCached(CACHE_REACTION_TOTAL_KEY(reaction, uri), total),
+    ])
+    return { total, viewerHas: true }
+  }
+
+  async recordUnreaction(
+    reaction: Reaction,
+    uri: string,
+    viewerDid: string,
+    totalBefore: number,
+  ): Promise<ReactionState> {
+    const total = Math.max(totalBefore - 1, 0)
+    await Promise.all([
+      this.setCached(CACHE_VIEWER_REACTION_KEY(reaction, uri, viewerDid), null),
+      this.setCached(CACHE_REACTION_TOTAL_KEY(reaction, uri), total),
+    ])
+    return { total, viewerHas: false }
   }
 
   // Included collections resolve to a summary, not their items, so a view's work is bounded by
@@ -233,4 +353,46 @@ export class CollectionsUtils {
       }),
     )
   }
+
+  /** Collections the account follows, newest follow first. Unresolvable subjects are dropped. */
+  async listFollowedCollections(
+    identifier: string,
+    limit: number,
+    cursor?: string,
+  ): Promise<Paginated<CollectionSummary>> {
+    const miniDoc = await this.deps.resolveIdentity(identifier)
+    const { cursor: nextCursor, records } = await this.deps.listFollows(miniDoc, limit, cursor)
+    const subjects = new Map<string, { did: string; rkey: string }>()
+    for (const record of records) {
+      const subject = parseSubjectRef(record.subject)
+      if (subject?.kind === 'collection') subjects.set(subject.uri, subject)
+    }
+    return {
+      cursor: nextCursor,
+      items: await this.hydrate([...subjects.values()], async (owner, subject) => {
+        const stored = await this.getStoredRecord(owner, subject.rkey)
+        return stored && toSummary(owner, subject.rkey, stored)
+      }),
+    }
+  }
+
+  /**
+   * Turns entries into summaries via `build`, dropping any entry whose author no longer resolves
+   * (deleted, deactivated) or that `build` rejects.
+   */
+  async hydrate<T extends { did: string }>(
+    entries: T[],
+    build: (miniDoc: MiniDoc, entry: T) => Promise<CollectionSummary | null> | CollectionSummary,
+  ): Promise<CollectionSummary[]> {
+    const summaries = await Promise.all(
+      entries.map(async entry => {
+        try {
+          return await build(await this.deps.resolveIdentity(entry.did), entry)
+        } catch {
+          return null
+        }
+      }),
+    )
+    return summaries.filter(summary => summary !== null)
+  }
 }
diff --git a/server/utils/atproto/utils/likes.ts b/server/utils/atproto/utils/likes.ts
index 54101e2b8e..be63cc1411 100644
--- a/server/utils/atproto/utils/likes.ts
+++ b/server/utils/atproto/utils/likes.ts
@@ -40,6 +40,20 @@ export function aggregateBacklinksByDay(
     .map(([day, likes]) => ({ day, likes }))
 }
 
+/** For callers that cache Constellation results themselves. */
+export function createUncachedConstellation() {
+  return new Constellation(
+    async <T = unknown>(
+      url: string,
+      options: Parameters<typeof $fetch>[1] = {},
+      _ttl?: number,
+    ): Promise<CachedFetchResult<T>> => {
+      const data = (await $fetch<T>(url, options)) as T
+      return { data, isStale: false, cachedAt: null }
+    },
+  )
+}
+
 /** The subset of Constellation that PackageLikesUtils actually needs. */
 export type ConstellationLike = Pick<Constellation, 'getBackLinks' | 'getLinksDistinctDids'>
 
@@ -51,19 +65,8 @@ export class PackageLikesUtils {
   private readonly cache: CacheAdapter
 
   constructor(deps?: { constellation?: ConstellationLike; cache?: CacheAdapter }) {
-    this.constellation =
-      deps?.constellation ??
-      new Constellation(
-        // Passes in a fetch wrapped as CachedFetch because we're already doing some heavy caching here
-        async <T = unknown>(
-          url: string,
-          options: Parameters<typeof $fetch>[1] = {},
-          _ttl?: number,
-        ): Promise<CachedFetchResult<T>> => {
-          const data = (await $fetch<T>(url, options)) as T
-          return { data, isStale: false, cachedAt: null }
-        },
-      )
+    // Uncached because we're already doing some heavy caching here
+    this.constellation = deps?.constellation ?? createUncachedConstellation()
     this.cache = deps?.cache ?? getCacheAdapter('generic')
   }
 
diff --git a/shared/types/social.ts b/shared/types/social.ts
index e7f8edf3ce..0f26d738df 100644
--- a/shared/types/social.ts
+++ b/shared/types/social.ts
@@ -69,8 +69,18 @@ export type CollectionItemView =
 /** One of the viewer's own collections, with what's in it. */
 export type OwnCollection = CollectionSummary & { subjectRefs: string[] }
 
+/** Likes or follows of a collection, counted once per account. */
+export type ReactionState = {
+  total: number
+  // False when not logged in. For follows, only about follow records: owners follow their own
+  // collections implicitly.
+  viewerHas: boolean
+}
+
 export type CollectionView = CollectionSummary & {
   items: CollectionItemView[]
+  likes: ReactionState
+  follows: ReactionState
 }
 
 /**
diff --git a/shared/utils/constants.ts b/shared/utils/constants.ts
index 26aa00ba0c..e968b375f5 100644
--- a/shared/utils/constants.ts
+++ b/shared/utils/constants.ts
@@ -66,6 +66,7 @@ export const PACKAGE_SUBJECT_REF = (packageName: string) =>
 export const LIKES_SCOPE = `repo:${dev.npmx.feed.like.$nsid}`
 export const PROFILE_SCOPE = `repo:${dev.npmx.actor.profile.$nsid}`
 export const COLLECTIONS_SCOPE = `repo:${dev.npmx.collection.$nsid}`
+export const FOLLOWS_SCOPE = `repo:${dev.npmx.graph.follow.$nsid}`
 export const COLLECTION_SUBJECT_REF = (did: string, rkey: string) =>
   `at://${did}/${dev.npmx.collection.$nsid}/${rkey}`
 // Keep in sync with lexicons/dev/npmx/collection.json
diff --git a/test/nuxt/a11y.spec.ts b/test/nuxt/a11y.spec.ts
index 05c2d97171..701396b05a 100644
--- a/test/nuxt/a11y.spec.ts
+++ b/test/nuxt/a11y.spec.ts
@@ -365,6 +365,8 @@ import CollectionGrid from '~/components/Collection/Grid.vue'
 import CollectionEditor from '~/components/Collection/Editor.vue'
 import PackageTypeahead from '~/components/Package/Typeahead.vue'
 import CollectionItemList from '~/components/Collection/ItemList.vue'
+import CollectionLikeButton from '~/components/Collection/LikeButton.vue'
+import CollectionFollowButton from '~/components/Collection/FollowButton.vue'
 import CollectionYourData from '~/components/Collection/YourData.vue'
 import type { CollectionItemView, CollectionSummary } from '#shared/types/social'
 import SizeIncrease from '~/components/Package/SizeIncrease.vue'
@@ -1355,6 +1357,30 @@ describe('component accessibility audits', () => {
       expect(results.violations).toEqual([])
     })
 
+    it('CollectionLikeButton should have no accessibility violations', async () => {
+      const component = await mountSuspended(CollectionLikeButton, {
+        props: {
+          identifier: summary.did,
+          rkey: summary.rkey,
+          modelValue: { total: 4, viewerHas: true },
+        },
+      })
+      const results = await runAxe(component)
+      expect(results.violations).toEqual([])
+    })
+
+    it('CollectionFollowButton should have no accessibility violations', async () => {
+      const component = await mountSuspended(CollectionFollowButton, {
+        props: {
+          identifier: summary.did,
+          rkey: summary.rkey,
+          modelValue: { total: 3, viewerHas: true },
+        },
+      })
+      const results = await runAxe(component)
+      expect(results.violations).toEqual([])
+    })
+
     it('CollectionYourData should have no accessibility violations', async () => {
       const component = await mountSuspended(CollectionYourData)
       await component.find('summary').trigger('click')
diff --git a/test/unit/server/utils/collection-writes.spec.ts b/test/unit/server/utils/collection-writes.spec.ts
index c2b91c2c63..d4cf08b722 100644
--- a/test/unit/server/utils/collection-writes.spec.ts
+++ b/test/unit/server/utils/collection-writes.spec.ts
@@ -28,6 +28,7 @@ const utils = {
   getStoredRecord: vi.fn(),
   getViewerReaction: vi.fn(),
   getReaction: vi.fn(),
+  getReactionTotal: vi.fn(async () => 4),
   recordReaction: vi.fn(async () => ({ total: 1, viewerHas: true })),
   recordUnreaction: vi.fn(async () => ({ total: 0, viewerHas: false })),
 }
@@ -140,6 +141,73 @@ describe('updateCollection', () => {
   })
 })
 
+describe('setReaction', () => {
+  it('follows with a follow record pointing at the collection', async () => {
+    client.create.mockResolvedValue({ uri: `at://${VIEWER}/dev.npmx.graph.follow/3follow` })
+    expect(await writes.setReaction(sessionFor(VIEWER), REF, 'follow', true)).toEqual({
+      total: 1,
+      viewerHas: true,
+    })
+    expect(throwOnMissingOAuthScope).toHaveBeenCalledWith(
+      expect.anything(),
+      'repo:dev.npmx.graph.follow',
+    )
+    expect(client.create).toHaveBeenCalledWith(
+      expect.objectContaining({ $nsid: 'dev.npmx.graph.follow' }),
+      expect.objectContaining({ subject: URI }),
+    )
+    expect(utils.recordReaction).toHaveBeenCalledWith('follow', URI, VIEWER, '3follow', 4)
+  })
+
+  it('likes via subjectRef', async () => {
+    client.create.mockResolvedValue({ uri: `at://${VIEWER}/dev.npmx.feed.like/3like` })
+    await writes.setReaction(sessionFor(VIEWER), REF, 'like', true)
+    expect(client.create).toHaveBeenCalledWith(
+      expect.objectContaining({ $nsid: 'dev.npmx.feed.like' }),
+      expect.objectContaining({ subjectRef: URI }),
+    )
+  })
+
+  it('writes nothing when already in the requested state', async () => {
+    utils.getReaction.mockResolvedValue({ total: 5, viewerHas: false })
+    expect(await writes.setReaction(sessionFor(VIEWER), REF, 'follow', false)).toEqual({
+      total: 5,
+      viewerHas: false,
+    })
+    expect(client.create).not.toHaveBeenCalled()
+    expect(client.delete).not.toHaveBeenCalled()
+  })
+
+  it('unfollows by deleting the viewer’s follow record', async () => {
+    utils.getViewerReaction.mockResolvedValue({
+      did: VIEWER,
+      collection: 'dev.npmx.graph.follow',
+      rkey: '3follow',
+    })
+    await writes.setReaction(sessionFor(VIEWER), REF, 'follow', false)
+    expect(client.delete).toHaveBeenCalledWith(
+      expect.objectContaining({ $nsid: 'dev.npmx.graph.follow' }),
+      { rkey: '3follow' },
+    )
+    expect(utils.recordUnreaction).toHaveBeenCalledWith('follow', URI, VIEWER, 4)
+  })
+
+  it('refuses to follow your own collection', async () => {
+    await expect(writes.setReaction(sessionFor(OWNER), REF, 'follow', true)).rejects.toMatchObject({
+      statusCode: 400,
+    })
+    expect(client.create).not.toHaveBeenCalled()
+  })
+
+  it('refuses to follow a collection that does not exist', async () => {
+    utils.getStoredRecord.mockResolvedValue(null)
+    await expect(writes.setReaction(sessionFor(VIEWER), REF, 'follow', true)).rejects.toMatchObject(
+      { statusCode: 404 },
+    )
+    expect(client.create).not.toHaveBeenCalled()
+  })
+})
+
 describe('buildCollectionRecord', () => {
   it('stamps createdAt for new records and omits empty optional fields', () => {
     expect(
diff --git a/test/unit/server/utils/collections.spec.ts b/test/unit/server/utils/collections.spec.ts
index 08bd774cda..0a85e2d4d7 100644
--- a/test/unit/server/utils/collections.spec.ts
+++ b/test/unit/server/utils/collections.spec.ts
@@ -1,6 +1,7 @@
 import { describe, expect, it, vi } from 'vite-plus/test'
 import type { CacheAdapter } from '#server/utils/cache/shared'
 import type { MiniDoc } from '#shared/types/social'
+import type { Backlink } from '#shared/utils/constellation'
 import { COLLECTION_SUBJECT_REF, PACKAGE_SUBJECT_REF } from '#shared/utils/constants'
 
 const { CollectionsUtils } = await import('#server/utils/atproto/utils/collections')
@@ -42,19 +43,33 @@ type RecordMap = Record<string, unknown>
 const key = (did: string, rkey: string) => `${did}/${rkey}`
 
 function setup(records: RecordMap, overrides: Partial<Deps> = {}) {
+  const constellation = {
+    getBackLinks: vi.fn(async (..._args: unknown[]) => ({
+      data: { total: 0, records: [] as Backlink[], cursor: undefined as string | undefined },
+      isStale: false,
+      cachedAt: null,
+    })),
+    getLinksDistinctDids: vi.fn(async (..._args: unknown[]) => ({
+      data: { total: 0, linking_dids: [] as string[], cursor: undefined as string | undefined },
+      isStale: false,
+      cachedAt: null,
+    })),
+  }
   const fetchRecord = vi.fn(async (doc: MiniDoc, rkey: string) => {
     const value = records[key(doc.did, rkey)]
     return value ? { uri: COLLECTION_SUBJECT_REF(doc.did, rkey), cid: `cid-${rkey}`, value } : null
   })
   const deps: Deps = {
+    constellation: constellation as unknown as Deps['constellation'],
     cache: memoryCache(),
     resolveIdentity: async identifier => miniDoc(identifier),
     fetchRecord,
     listRecords: async () => ({ records: [] }),
+    listFollows: async () => ({ records: [] }),
     packageExists: async name => name !== 'does-not-exist',
     ...overrides,
   }
-  return { utils: new CollectionsUtils(deps), fetchRecord }
+  return { utils: new CollectionsUtils(deps), constellation, fetchRecord }
 }
 
 describe('CollectionsUtils.getCollection', () => {
@@ -147,6 +162,46 @@ describe('CollectionsUtils.getCollection', () => {
     ])
   })
 
+  it('aggregates like and follow stats', async () => {
+    const { utils, constellation } = setup({ [key(ALICE, RKEY_A)]: record('A', []) })
+    constellation.getLinksDistinctDids.mockImplementation(async (...args: unknown[]) => ({
+      data: {
+        total: args[1] === 'dev.npmx.feed.like' ? 7 : 2,
+        linking_dids: [],
+        cursor: undefined,
+      },
+      isStale: false,
+      cachedAt: null,
+    }))
+    constellation.getBackLinks.mockImplementation(async (...args: unknown[]) => ({
+      data: {
+        total: args[1] === 'dev.npmx.feed.like' ? 1 : 3,
+        records:
+          args[1] === 'dev.npmx.feed.like'
+            ? [{ did: BOB, collection: 'dev.npmx.feed.like', rkey: '3likerkey' }]
+            : [],
+        cursor: undefined,
+      },
+      isStale: false,
+      cachedAt: null,
+    }))
+
+    const view = await utils.getCollection(ALICE, RKEY_A, BOB)
+
+    expect(view).toMatchObject({
+      likes: { total: 7, viewerHas: true },
+      follows: { total: 2, viewerHas: false },
+    })
+    expect(constellation.getLinksDistinctDids).toHaveBeenCalledWith(
+      COLLECTION_SUBJECT_REF(ALICE, RKEY_A),
+      'dev.npmx.feed.like',
+      '.subjectRef',
+      1,
+      undefined,
+      0,
+    )
+  })
+
   it('caches records, including misses', async () => {
     const { utils, fetchRecord } = setup({ [key(ALICE, RKEY_A)]: record('A', []) })
     await utils.getCollection(ALICE, RKEY_A)
@@ -157,6 +212,88 @@ describe('CollectionsUtils.getCollection', () => {
   })
 })
 
+describe('CollectionsUtils reactions', () => {
+  const uri = COLLECTION_SUBJECT_REF(ALICE, RKEY_A)
+
+  it.each([
+    ['like', 'dev.npmx.feed.like', '.subjectRef'],
+    ['follow', 'dev.npmx.graph.follow', '.subject'],
+  ] as const)(
+    'counts a %s immediately, before Constellation sees it',
+    async (reaction, nsid, path) => {
+      const { utils, constellation } = setup({})
+      constellation.getLinksDistinctDids.mockResolvedValue({
+        data: { total: 2, linking_dids: [], cursor: undefined },
+        isStale: false,
+        cachedAt: null,
+      })
+
+      const before = await utils.getReactionTotal(reaction, uri)
+      expect(await utils.recordReaction(reaction, uri, BOB, '3recordkey', before)).toEqual({
+        total: 3,
+        viewerHas: true,
+      })
+      expect(await utils.getReaction(reaction, uri, BOB)).toEqual({ total: 3, viewerHas: true })
+      expect(await utils.getViewerReaction(reaction, uri, BOB)).toEqual({
+        did: BOB,
+        collection: nsid,
+        rkey: '3recordkey',
+      })
+      expect(constellation.getLinksDistinctDids).toHaveBeenCalledWith(
+        uri,
+        nsid,
+        path,
+        1,
+        undefined,
+        0,
+      )
+
+      expect(await utils.recordUnreaction(reaction, uri, BOB, 3)).toEqual({
+        total: 2,
+        viewerHas: false,
+      })
+      expect(await utils.getViewerReaction(reaction, uri, BOB)).toBeNull()
+      expect(constellation.getLinksDistinctDids).toHaveBeenCalledTimes(1)
+    },
+  )
+
+  it('keeps likes and follows apart', async () => {
+    const { utils } = setup({})
+    await utils.recordReaction('like', uri, BOB, '3likerkey', 0)
+    expect(await utils.getReaction('follow', uri, BOB)).toEqual({ total: 0, viewerHas: false })
+  })
+
+  it('never goes below zero', async () => {
+    const { utils } = setup({})
+    expect(await utils.recordUnreaction('like', uri, BOB, 0)).toEqual({
+      total: 0,
+      viewerHas: false,
+    })
+  })
+})
+
+describe('CollectionsUtils.listFollowedCollections', () => {
+  it('hydrates followed collections and drops unknown, missing and duplicate subjects', async () => {
+    const { utils } = setup(
+      { [key(ALICE, RKEY_A)]: record('Parsers', []) },
+      {
+        listFollows: async () => ({
+          cursor: 'next',
+          records: [
+            { rkey: 'f1', subject: COLLECTION_SUBJECT_REF(ALICE, RKEY_A) },
+            { rkey: 'f2', subject: COLLECTION_SUBJECT_REF(ALICE, RKEY_A) },
+            { rkey: 'f3', subject: COLLECTION_SUBJECT_REF(ALICE, RKEY_B) },
+            { rkey: 'f4', subject: 'at://did:plc:alice/app.bsky.feed.post/3abc' },
+          ],
+        }),
+      },
+    )
+    const page = await utils.listFollowedCollections(BOB, 10)
+    expect(page.cursor).toBe('next')
+    expect(page.items.map(c => c.name)).toEqual(['Parsers'])
+  })
+})
+
 describe('CollectionsUtils.listUserCollections', () => {
   it('returns summaries with the record key', async () => {
     const { utils } = setup(