diff --git a/client/api/api.ts b/client/api/api.ts
index 3bcd31c7..f00c6c06 100644
--- a/client/api/api.ts
+++ b/client/api/api.ts
@@ -288,6 +288,22 @@ async function getRewindStats(args: timeframe): Promise<RewindStats> {
   return handleJson<RewindStats>(r);
 }
 
+async function getTrackFeedback(trackId: number): Promise<TrackFeedback> {
+  return apiFetch<TrackFeedback>(`/apis/web/v1/track/${trackId}/feedback`);
+}
+
+async function setTrackFeedback(
+  trackId: number,
+  score: number,
+): Promise<TrackFeedback> {
+  const r = await fetch(`/apis/web/v1/track/${trackId}/feedback`, {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify({ score }),
+  });
+  return handleJson<TrackFeedback>(r);
+}
+
 export {
   getTopAlbums,
   search,
@@ -315,6 +331,8 @@ export {
   getExport,
   submitListen,
   getRewindStats,
+  getTrackFeedback,
+  setTrackFeedback,
 };
 type ImageList = {
   xs: string;
@@ -441,6 +459,9 @@ type NowPlaying = {
   currently_playing: boolean;
   track: Track;
 };
+type TrackFeedback = {
+  score: number;
+};
 type RewindStats = {
   title: string;
   top_artists: Ranked<Artist>[];
@@ -481,4 +502,5 @@ export type {
   Stats,
   RewindStats,
   ImageList,
+  TrackFeedback,
 };
diff --git a/client/app/routes/MediaItems/MediaLayout.tsx b/client/app/routes/MediaItems/MediaLayout.tsx
index ca8db0fe..62fdd33c 100644
--- a/client/app/routes/MediaItems/MediaLayout.tsx
+++ b/client/app/routes/MediaItems/MediaLayout.tsx
@@ -1,8 +1,13 @@
 import React, { useEffect, useState } from "react";
 import { average } from "color.js";
-import { type ImageList, type SearchResponse } from "api/api";
+import {
+  getTrackFeedback,
+  setTrackFeedback,
+  type ImageList,
+  type SearchResponse,
+} from "api/api";
 import ImageDropHandler from "~/components/ImageDropHandler";
-import { Edit, ImageIcon, Merge, Plus, Trash } from "lucide-react";
+import { Edit, Heart, ImageIcon, Merge, Plus, Trash } from "lucide-react";
 import { useAppContext } from "~/providers/AppProvider";
 import MergeModal from "~/components/modals/MergeModal";
 import ImageReplaceModal from "~/components/modals/ImageReplaceModal";
@@ -13,6 +18,7 @@ import MbzIcon from "~/components/icons/MbzIcon";
 import { timeListenedString } from "~/utils/utils";
 import { Link } from "react-router";
 import useWindowWidth from "~/hooks/useWindowWidth";
+import { useQuery, useQueryClient } from "@tanstack/react-query";
 
 export type MergeFunc = (
   from: number,
@@ -48,7 +54,10 @@ export default function MediaLayout(props: Props) {
   const [imageModalOpen, setImageModalOpen] = useState(false);
   const [renameModalOpen, setRenameModalOpen] = useState(false);
   const [addListenModalOpen, setAddListenModalOpen] = useState(false);
+  const [feedbackPending, setFeedbackPending] = useState(false);
   const { user } = useAppContext();
+  const queryClient = useQueryClient();
+  const feedbackQueryKey = ["track-feedback", props.id] as const;
 
   useEffect(() => {
     average(props.img.xs, { amount: 1 }).then((color) => {
@@ -56,6 +65,28 @@ export default function MediaLayout(props: Props) {
     });
   }, [props.img]);
 
+  const { data: feedback } = useQuery({
+    queryKey: feedbackQueryKey,
+    queryFn: () => getTrackFeedback(props.id),
+    enabled: !!user && props.type === "Track",
+  });
+  const loved = feedback?.score === 1;
+
+  const toggleLove = async () => {
+    if (feedbackPending || props.type !== "Track") return;
+    const previous = feedback ?? { score: 0 };
+    const next = { score: loved ? 0 : 1 };
+    queryClient.setQueryData(feedbackQueryKey, next);
+    setFeedbackPending(true);
+    try {
+      await setTrackFeedback(props.id, next.score);
+    } catch {
+      queryClient.setQueryData(feedbackQueryKey, previous);
+    } finally {
+      setFeedbackPending(false);
+    }
+  };
+
   const replaceImageCallback = () => {
     window.location.reload();
   };
@@ -152,6 +183,18 @@ export default function MediaLayout(props: Props) {
               <>
                 {props.type === "Track" && (
                   <>
+                    <button
+                      title={loved ? "Unlove" : "Love"}
+                      className="hover:cursor-pointer"
+                      disabled={feedbackPending}
+                      onClick={toggleLove}
+                    >
+                      <Heart
+                        size={iconSize}
+                        fill={loved ? "currentColor" : "none"}
+                        className="hover:stroke-(--color-fg-secondary) hover:text-(--color-fg-secondary)"
+                      />
+                    </button>
                     <button
                       title="Add Listen"
                       className="hover:cursor-pointer"
diff --git a/db/migrations_sqlite/003_recording_feedback.sql b/db/migrations_sqlite/003_recording_feedback.sql
new file mode 100644
index 00000000..38d0badd
--- /dev/null
+++ b/db/migrations_sqlite/003_recording_feedback.sql
@@ -0,0 +1,17 @@
+-- +goose Up
+
+CREATE TABLE IF NOT EXISTS recording_feedback (
+    user_id    INTEGER NOT NULL REFERENCES users(id) ON DELETE CASCADE,
+    track_id   INTEGER NOT NULL REFERENCES tracks(id) ON DELETE CASCADE,
+    score      INTEGER NOT NULL CHECK (score IN (1, -1)),
+    created_at INTEGER NOT NULL,
+    updated_at INTEGER NOT NULL,
+    PRIMARY KEY (user_id, track_id)
+);
+
+CREATE INDEX IF NOT EXISTS idx_recording_feedback_track_id ON recording_feedback(track_id);
+
+-- +goose Down
+
+DROP INDEX IF EXISTS idx_recording_feedback_track_id;
+DROP TABLE IF EXISTS recording_feedback;
diff --git a/engine/handlers/get_track.go b/engine/handlers/get_track.go
index 99f11535..e5666aec 100644
--- a/engine/handlers/get_track.go
+++ b/engine/handlers/get_track.go
@@ -118,3 +118,36 @@ func GetTrackInterestHandler(store db.ListenStore) http.HandlerFunc {
 		utils.WriteJSON(w, http.StatusOK, interest)
 	}
 }
+
+// GetTrackFeedbackHandler returns feedback score for a track.
+func GetTrackFeedbackHandler(store db.DB) http.HandlerFunc {
+	return func(w http.ResponseWriter, r *http.Request) {
+		ctx := r.Context()
+		l := logger.FromContext(ctx)
+
+		trackID, err := utils.ParseIDParam(r, "id")
+		if err != nil {
+			l.Debug().AnErr("error", err).Msg("GetTrackFeedbackHandler: Invalid track id")
+			utils.WriteError(w, "invalid track id", http.StatusBadRequest)
+			return
+		}
+
+		user, err := store.GetAdminUser(ctx)
+		if err != nil || user == nil {
+			l.Err(err).Msg("GetTrackFeedbackHandler: Failed to get admin user")
+			utils.WriteError(w, "failed to retrieve feedback", http.StatusInternalServerError)
+			return
+		}
+
+		score, err := store.GetTrackFeedback(ctx, user.ID, trackID)
+		if err != nil {
+			l.Err(err).Msg("GetTrackFeedbackHandler: Failed to get feedback")
+			utils.WriteError(w, "failed to retrieve feedback", http.StatusInternalServerError)
+			return
+		}
+
+		utils.WriteJSON(w, http.StatusOK, struct {
+			Score int `json:"score"`
+		}{Score: score})
+	}
+}
diff --git a/engine/handlers/lbz_get_feedback.go b/engine/handlers/lbz_get_feedback.go
new file mode 100644
index 00000000..02b1d002
--- /dev/null
+++ b/engine/handlers/lbz_get_feedback.go
@@ -0,0 +1,185 @@
+package handlers
+
+import (
+	"errors"
+	"net/http"
+	"strconv"
+	"strings"
+
+	"github.com/gabehf/koito/internal/db"
+	"github.com/gabehf/koito/internal/logger"
+	"github.com/gabehf/koito/internal/models"
+	"github.com/gabehf/koito/internal/utils"
+	"github.com/google/uuid"
+)
+
+const (
+	lbzFeedbackDefaultCount = 25
+	lbzFeedbackMaxCount     = 100
+)
+
+type lbzFeedbackItem struct {
+	UserID        string  `json:"user_id"`
+	RecordingMSID *string `json:"recording_msid"`
+	RecordingMBID *string `json:"recording_mbid"`
+	Score         int     `json:"score"`
+	Created       int64   `json:"created,omitempty"`
+}
+
+// LbzGetUserFeedbackHandler returns paginated feedback.
+//
+// The {user_name} path segment is accepted for ListenBrainz API compatibility but
+// ignored for now (Koito is single-user; feedback is always the admin's).
+// TODO: validate/match user_name when multi-user support is added.
+func LbzGetUserFeedbackHandler(store db.DB) http.HandlerFunc {
+	return func(w http.ResponseWriter, r *http.Request) {
+		ctx := r.Context()
+		l := logger.FromContext(ctx)
+
+		user, ok := lbzFeedbackUser(w, r, store)
+		if !ok {
+			return
+		}
+
+		offset := 0
+		if raw := r.URL.Query().Get("offset"); raw != "" {
+			v, err := strconv.Atoi(raw)
+			if err != nil || v < 0 {
+				utils.WriteError(w, "offset must be a non-negative integer", http.StatusBadRequest)
+				return
+			}
+			offset = v
+		}
+
+		count := lbzFeedbackDefaultCount
+		if raw := r.URL.Query().Get("count"); raw != "" {
+			v, err := strconv.Atoi(raw)
+			if err != nil || v < 1 {
+				utils.WriteError(w, "count must be a positive integer", http.StatusBadRequest)
+				return
+			}
+			count = v
+		}
+		count = min(count, lbzFeedbackMaxCount)
+
+		var scoreFilter *int
+		if raw := r.URL.Query().Get("score"); raw != "" {
+			v, err := strconv.Atoi(raw)
+			if err != nil || (v != 1 && v != -1) {
+				utils.WriteError(w, "score must be 1 or -1", http.StatusBadRequest)
+				return
+			}
+			scoreFilter = &v
+		}
+
+		items, total, err := store.ListUserFeedback(ctx, db.ListUserFeedbackOpts{
+			UserID: user.ID,
+			Score:  scoreFilter,
+			Limit:  count,
+			Offset: offset,
+		})
+		if err != nil {
+			l.Err(err).Msg("LbzGetUserFeedbackHandler: Failed to list feedback")
+			utils.WriteError(w, "failed to retrieve feedback", http.StatusInternalServerError)
+			return
+		}
+
+		feedback := make([]lbzFeedbackItem, len(items))
+		for i, item := range items {
+			feedback[i] = toLbzFeedbackItem(user.Username, item)
+		}
+		utils.WriteJSON(w, http.StatusOK, map[string]any{
+			"count":       len(feedback),
+			"feedback":    feedback,
+			"offset":      offset,
+			"total_count": total,
+		})
+	}
+}
+
+// LbzGetFeedbackForRecordingsHandler returns feedback scores for the given recordings.
+//
+// The {user_name} path segment is accepted for ListenBrainz API compatibility but
+// ignored for now (Koito is single-user; feedback is always the admin's).
+// TODO: validate/match user_name when multi-user support is added.
+func LbzGetFeedbackForRecordingsHandler(store db.DB) http.HandlerFunc {
+	return func(w http.ResponseWriter, r *http.Request) {
+		ctx := r.Context()
+		l := logger.FromContext(ctx)
+
+		user, ok := lbzFeedbackUser(w, r, store)
+		if !ok {
+			return
+		}
+
+		mbids, err := parseRecordingMBIDs(r)
+		if err != nil {
+			utils.WriteError(w, err.Error(), http.StatusBadRequest)
+			return
+		}
+
+		items, err := store.GetFeedbackForRecordings(ctx, db.GetFeedbackForRecordingsOpts{
+			UserID: user.ID,
+			MBIDs:  mbids,
+		})
+		if err != nil {
+			l.Err(err).Msg("LbzGetFeedbackForRecordingsHandler: Failed to get feedback")
+			utils.WriteError(w, "failed to retrieve feedback", http.StatusInternalServerError)
+			return
+		}
+
+		feedback := make([]lbzFeedbackItem, len(items))
+		for i, item := range items {
+			feedback[i] = toLbzFeedbackItem(user.Username, item)
+		}
+		utils.WriteJSON(w, http.StatusOK, map[string]any{"feedback": feedback})
+	}
+}
+
+func lbzFeedbackUser(w http.ResponseWriter, r *http.Request, store db.UserStore) (*models.User, bool) {
+	u, err := store.GetAdminUser(r.Context())
+	if err != nil || u == nil {
+		logger.FromContext(r.Context()).Err(err).Msg("lbzFeedbackUser: Failed to get admin user")
+		utils.WriteError(w, "failed to look up user", http.StatusInternalServerError)
+		return nil, false
+	}
+	return u, true
+}
+
+func toLbzFeedbackItem(username string, item db.RecordingFeedback) lbzFeedbackItem {
+	out := lbzFeedbackItem{UserID: username, Score: item.Score, Created: item.CreatedAt}
+	if item.RecordingMBID != nil {
+		s := item.RecordingMBID.String()
+		out.RecordingMBID = &s
+	}
+	return out
+}
+
+func parseRecordingMBIDs(r *http.Request) ([]uuid.UUID, error) {
+	var raw []string
+	if r.Method == http.MethodPost {
+		body, err := utils.DecodeBody[struct {
+			RecordingMBIDs []string `json:"recording_mbids"`
+		}](r)
+		if err != nil {
+			return nil, errors.New("invalid JSON sent")
+		}
+		raw = body.RecordingMBIDs
+	} else if param := r.URL.Query().Get("recording_mbids"); param != "" {
+		raw = strings.Split(param, ",")
+	}
+
+	mbids := make([]uuid.UUID, 0, len(raw))
+	for _, s := range raw {
+		s = strings.TrimSpace(s)
+		if s == "" {
+			continue
+		}
+		id, err := uuid.Parse(s)
+		if err != nil {
+			return nil, errors.New("invalid recording_mbid")
+		}
+		mbids = append(mbids, id)
+	}
+	return mbids, nil
+}
diff --git a/engine/handlers/lbz_submit_recording_feedback.go b/engine/handlers/lbz_submit_recording_feedback.go
new file mode 100644
index 00000000..ff5c8595
--- /dev/null
+++ b/engine/handlers/lbz_submit_recording_feedback.go
@@ -0,0 +1,65 @@
+package handlers
+
+import (
+	"errors"
+	"net/http"
+
+	"github.com/gabehf/koito/engine/middleware"
+	"github.com/gabehf/koito/internal/db"
+	"github.com/gabehf/koito/internal/logger"
+	"github.com/gabehf/koito/internal/utils"
+	"github.com/google/uuid"
+)
+
+// LbzSubmitRecordingFeedbackHandler submits love/hate feedback for a recording.
+func LbzSubmitRecordingFeedbackHandler(store db.DB) http.HandlerFunc {
+	return func(w http.ResponseWriter, r *http.Request) {
+		ctx := r.Context()
+		l := logger.FromContext(ctx)
+
+		u := middleware.GetUserFromContext(ctx)
+		if u == nil {
+			utils.WriteError(w, "unauthorized", http.StatusUnauthorized)
+			return
+		}
+
+		body, err := utils.DecodeBody[struct {
+			RecordingMBID string `json:"recording_mbid"`
+			Score         int    `json:"score"`
+		}](r)
+		if err != nil {
+			utils.WriteError(w, "invalid JSON sent", http.StatusBadRequest)
+			return
+		}
+		if body.Score != 1 && body.Score != -1 && body.Score != 0 {
+			utils.WriteError(w, "score must be 1, 0, or -1", http.StatusBadRequest)
+			return
+		}
+
+		mbid, err := uuid.Parse(body.RecordingMBID)
+		if err != nil {
+			utils.WriteError(w, "recording_mbid is required", http.StatusBadRequest)
+			return
+		}
+
+		track, err := store.GetTrack(ctx, db.GetTrackOpts{MusicBrainzID: mbid})
+		if err != nil {
+			if errors.Is(err, db.ErrNotFound) {
+				utils.WriteError(w, "track with specified recording_mbid could not be found", http.StatusNotFound)
+				return
+			}
+			l.Err(err).Msg("LbzSubmitRecordingFeedbackHandler: Failed to resolve track")
+			utils.WriteError(w, "failed to resolve track", http.StatusInternalServerError)
+			return
+		}
+
+		if err := store.SetTrackFeedback(ctx, u.ID, track.ID, body.Score); err != nil {
+			l.Err(err).Msg("LbzSubmitRecordingFeedbackHandler: Failed to save feedback")
+			utils.WriteError(w, "failed to save feedback", http.StatusInternalServerError)
+			return
+		}
+
+		w.Header().Set("Content-Type", "application/json")
+		w.Write([]byte(`{"status": "ok"}`))
+	}
+}
diff --git a/engine/handlers/post_track.go b/engine/handlers/post_track.go
index 5d34c089..535734fd 100644
--- a/engine/handlers/post_track.go
+++ b/engine/handlers/post_track.go
@@ -3,6 +3,7 @@ package handlers
 import (
 	"net/http"
 
+	"github.com/gabehf/koito/engine/middleware"
 	"github.com/gabehf/koito/internal/db"
 	"github.com/gabehf/koito/internal/logger"
 	"github.com/gabehf/koito/internal/utils"
@@ -74,3 +75,40 @@ func AddTrackArtistsHandler(store db.DB) http.HandlerFunc {
 		w.WriteHeader(http.StatusNoContent)
 	}
 }
+
+// SubmitTrackFeedbackHandler sets the current user's feedback score for a track.
+func SubmitTrackFeedbackHandler(store db.FeedbackStore) http.HandlerFunc {
+	return func(w http.ResponseWriter, r *http.Request) {
+		ctx := r.Context()
+		l := logger.FromContext(ctx)
+
+		u := middleware.GetUserFromContext(ctx)
+		if u == nil {
+			utils.WriteError(w, "unauthorized", http.StatusUnauthorized)
+			return
+		}
+
+		trackID, err := utils.ParseIDParam(r, "id")
+		if err != nil {
+			l.Debug().AnErr("error", err).Msg("SubmitTrackFeedbackHandler: Invalid track id")
+			utils.WriteError(w, "invalid track id", http.StatusBadRequest)
+			return
+		}
+
+		body, err := utils.DecodeBody[struct {
+			Score int `json:"score"`
+		}](r)
+		if err != nil || (body.Score != 1 && body.Score != -1 && body.Score != 0) {
+			utils.WriteError(w, "score must be 1, 0, or -1", http.StatusBadRequest)
+			return
+		}
+
+		if err := store.SetTrackFeedback(ctx, u.ID, trackID, body.Score); err != nil {
+			l.Err(err).Msg("SubmitTrackFeedbackHandler: Failed to save feedback")
+			utils.WriteError(w, "failed to save feedback", http.StatusInternalServerError)
+			return
+		}
+
+		utils.WriteJSON(w, http.StatusOK, body)
+	}
+}
diff --git a/engine/routes.go b/engine/routes.go
index 9176c46d..7c3193aa 100644
--- a/engine/routes.go
+++ b/engine/routes.go
@@ -55,6 +55,7 @@ func bindRoutes(
 			r.Get("/track/{id}/artists", handlers.GetArtistsForTrackHandler(db)) // done
 			r.Get("/track/{id}/aliases", handlers.GetTrackAliasesHandler(db))    // done
 			r.Get("/track/{id}/interest", handlers.GetTrackInterestHandler(db))  // done
+			r.Get("/track/{id}/feedback", handlers.GetTrackFeedbackHandler(db))
 
 			r.Get("/top/tracks", handlers.GetTopTracksHandler(db))
 			r.Get("/top/albums", handlers.GetTopAlbumsHandler(db))
@@ -118,6 +119,7 @@ func bindRoutes(
 			r.Patch("/track/{id}", handlers.UpdateTrackHandler(db))
 			r.Patch("/track/{id}/aliases/primary", handlers.SetPrimaryTrackAliasHandler(db))
 			r.Patch("/track/{id}/artists/{artist_id}", handlers.SetPrimaryTrackArtistHandler(db))
+			r.Post("/track/{id}/feedback", handlers.SubmitTrackFeedbackHandler(db))
 
 			r.Post("/listens", handlers.SubmitListenWithIDHandler(db))
 			r.Delete("/listens", handlers.DeleteListenHandler(db))
@@ -143,8 +145,15 @@ func bindRoutes(
 
 		r.With(middleware.Authenticate(db, middleware.AuthModeAPIKey)).
 			Post("/submit-listens", handlers.LbzSubmitListenHandler(db, mbz))
+		r.With(middleware.Authenticate(db, middleware.AuthModeAPIKey)).
+			Post("/feedback/recording-feedback", handlers.LbzSubmitRecordingFeedbackHandler(db))
 		r.With(middleware.Authenticate(db, middleware.AuthModeAPIKey)).
 			Get("/validate-token", handlers.LbzValidateTokenHandler())
+
+		// Feedback reads: LB-compatible paths; {user_name} ignored for now (single-user).
+		r.Get("/feedback/user/{user_name}/get-feedback", handlers.LbzGetUserFeedbackHandler(db))
+		r.Get("/feedback/user/{user_name}/get-feedback-for-recordings", handlers.LbzGetFeedbackForRecordingsHandler(db))
+		r.Post("/feedback/user/{user_name}/get-feedback-for-recordings", handlers.LbzGetFeedbackForRecordingsHandler(db))
 	})
 
 	// serve react client
diff --git a/internal/db/db.go b/internal/db/db.go
index 6e71d430..6cff3860 100644
--- a/internal/db/db.go
+++ b/internal/db/db.go
@@ -110,6 +110,13 @@ type ExportStore interface {
 	GetExportPage(ctx context.Context, opts GetExportPageOpts) ([]*ExportItem, error)
 }
 
+type FeedbackStore interface {
+	GetTrackFeedback(ctx context.Context, userID, trackID int32) (int, error)
+	SetTrackFeedback(ctx context.Context, userID, trackID int32, score int) error
+	ListUserFeedback(ctx context.Context, opts ListUserFeedbackOpts) ([]RecordingFeedback, int64, error)
+	GetFeedbackForRecordings(ctx context.Context, opts GetFeedbackForRecordingsOpts) ([]RecordingFeedback, error)
+}
+
 type DB interface {
 	ArtistStore
 	AlbumStore
@@ -118,6 +125,7 @@ type DB interface {
 	UserStore
 	ImageStore
 	ExportStore
+	FeedbackStore
 	Ping(ctx context.Context) error
 	Close(ctx context.Context)
 	PurgeAllData(ctx context.Context) error
diff --git a/internal/db/opts.go b/internal/db/opts.go
index ed9eea63..0b2fc6a0 100644
--- a/internal/db/opts.go
+++ b/internal/db/opts.go
@@ -167,3 +167,14 @@ type GetInterestOpts struct {
 	ArtistID int32
 	TrackID  int32
 }
+type ListUserFeedbackOpts struct {
+	UserID int32
+	Score  *int // nil = all; 1 or -1 to filter
+	Limit  int
+	Offset int
+}
+
+type GetFeedbackForRecordingsOpts struct {
+	UserID int32
+	MBIDs  []uuid.UUID
+}
diff --git a/internal/db/sqlite/feedback.go b/internal/db/sqlite/feedback.go
new file mode 100644
index 00000000..4b11df50
--- /dev/null
+++ b/internal/db/sqlite/feedback.go
@@ -0,0 +1,148 @@
+package sqlite
+
+import (
+	"context"
+	"database/sql"
+	"errors"
+	"fmt"
+	"strings"
+	"time"
+
+	"github.com/gabehf/koito/internal/db"
+	"github.com/google/uuid"
+)
+
+func (s *Sqlite) GetTrackFeedback(ctx context.Context, userID, trackID int32) (int, error) {
+	var score int
+	err := s.db.QueryRowContext(ctx,
+		`SELECT score FROM recording_feedback WHERE user_id = ? AND track_id = ?`,
+		userID, trackID,
+	).Scan(&score)
+	if errors.Is(err, sql.ErrNoRows) {
+		return 0, nil
+	}
+	if err != nil {
+		return 0, fmt.Errorf("GetTrackFeedback: %w", err)
+	}
+	return score, nil
+}
+
+func (s *Sqlite) SetTrackFeedback(ctx context.Context, userID, trackID int32, score int) error {
+	if score != 1 && score != -1 && score != 0 {
+		return fmt.Errorf("SetTrackFeedback: invalid score %d", score)
+	}
+	if score == 0 {
+		_, err := s.db.ExecContext(ctx,
+			`DELETE FROM recording_feedback WHERE user_id = ? AND track_id = ?`, userID, trackID)
+		return err
+	}
+
+	now := time.Now().Unix()
+	_, err := s.db.ExecContext(ctx, `
+		INSERT INTO recording_feedback (user_id, track_id, score, created_at, updated_at)
+		VALUES (?, ?, ?, ?, ?)
+		ON CONFLICT(user_id, track_id) DO UPDATE SET
+			score = excluded.score,
+			updated_at = excluded.updated_at`,
+		userID, trackID, score, now, now,
+	)
+	if err != nil {
+		return fmt.Errorf("SetTrackFeedback: %w", err)
+	}
+	return nil
+}
+func (s *Sqlite) ListUserFeedback(ctx context.Context, opts db.ListUserFeedbackOpts) ([]db.RecordingFeedback, int64, error) {
+	where := `WHERE rf.user_id = ?`
+	args := []any{opts.UserID}
+	if opts.Score != nil {
+		where += ` AND rf.score = ?`
+		args = append(args, *opts.Score)
+	}
+
+	var total int64
+	if err := s.db.QueryRowContext(ctx,
+		`SELECT COUNT(*) FROM recording_feedback rf `+where, args...,
+	).Scan(&total); err != nil {
+		return nil, 0, err
+	}
+
+	args = append(args, opts.Limit, opts.Offset)
+	rows, err := s.db.QueryContext(ctx, `
+		SELECT t.musicbrainz_id, rf.score, rf.created_at
+		FROM recording_feedback rf
+		JOIN tracks t ON t.id = rf.track_id
+		`+where+`
+		ORDER BY rf.created_at DESC
+		LIMIT ? OFFSET ?`, args...)
+	if err != nil {
+		return nil, 0, err
+	}
+	defer rows.Close()
+
+	items := []db.RecordingFeedback{}
+	for rows.Next() {
+		var mbid sql.NullString
+		var item db.RecordingFeedback
+		if err := rows.Scan(&mbid, &item.Score, &item.CreatedAt); err != nil {
+			return nil, 0, err
+		}
+		item.RecordingMBID = parseNullableUUID(mbid)
+		items = append(items, item)
+	}
+	return items, total, rows.Err()
+}
+
+func (s *Sqlite) GetFeedbackForRecordings(ctx context.Context, opts db.GetFeedbackForRecordingsOpts) ([]db.RecordingFeedback, error) {
+	mbids := opts.MBIDs
+	out := make([]db.RecordingFeedback, len(mbids))
+	for i := range mbids {
+		out[i].RecordingMBID = &mbids[i]
+	}
+	if len(mbids) == 0 {
+		return out, nil
+	}
+
+	placeholders := make([]string, len(mbids))
+	args := make([]any, 0, len(mbids)+1)
+	args = append(args, opts.UserID)
+	for i, mbid := range mbids {
+		placeholders[i] = "?"
+		args = append(args, mbid.String())
+	}
+
+	rows, err := s.db.QueryContext(ctx, `
+		SELECT t.musicbrainz_id, COALESCE(rf.score, 0), COALESCE(rf.created_at, 0)
+		FROM tracks t
+		LEFT JOIN recording_feedback rf ON rf.track_id = t.id AND rf.user_id = ?
+		WHERE t.musicbrainz_id IN (`+strings.Join(placeholders, ",")+`)`, args...)
+	if err != nil {
+		return nil, err
+	}
+	defer rows.Close()
+
+	found := make(map[uuid.UUID]db.RecordingFeedback, len(mbids))
+	for rows.Next() {
+		var mbidStr string
+		var item db.RecordingFeedback
+		if err := rows.Scan(&mbidStr, &item.Score, &item.CreatedAt); err != nil {
+			return nil, err
+		}
+		mbid, err := uuid.Parse(mbidStr)
+		if err != nil {
+			continue
+		}
+		item.RecordingMBID = &mbid
+		found[mbid] = item
+	}
+	if err := rows.Err(); err != nil {
+		return nil, err
+	}
+
+	for i, mbid := range mbids {
+		if item, ok := found[mbid]; ok {
+			out[i] = item
+			out[i].RecordingMBID = &mbids[i]
+		}
+	}
+	return out, nil
+}
diff --git a/internal/db/sqlite/sqlite.go b/internal/db/sqlite/sqlite.go
index 39893776..2fa8ec25 100644
--- a/internal/db/sqlite/sqlite.go
+++ b/internal/db/sqlite/sqlite.go
@@ -289,6 +289,7 @@ func (s *Sqlite) PurgeAllData(ctx context.Context) error {
 	// Order respects foreign-key dependencies; cascades clean up junction and
 	// alias tables automatically.
 	for _, stmt := range []string{
+		`DELETE FROM recording_feedback`,
 		`DELETE FROM listens`,
 		`DELETE FROM tracks`,
 		`DELETE FROM releases`,
diff --git a/internal/db/sqlite/track.go b/internal/db/sqlite/track.go
index 5ef4e5b6..2c859b2c 100644
--- a/internal/db/sqlite/track.go
+++ b/internal/db/sqlite/track.go
@@ -571,6 +571,18 @@ func (s *Sqlite) MergeTracks(ctx context.Context, fromId, toId int32) error {
 		return fmt.Errorf("MergeTracks: redirect listens: %w", err)
 	}
 
+	// redirect feedback; keep destination row on (user_id, track_id) conflict
+	if _, err := tx.ExecContext(ctx, `
+		INSERT OR IGNORE INTO recording_feedback (user_id, track_id, score, created_at, updated_at)
+		SELECT user_id, ?, score, created_at, updated_at
+		FROM recording_feedback WHERE track_id = ?`, toId, fromId); err != nil {
+		return fmt.Errorf("MergeTracks: redirect feedback: %w", err)
+	}
+	if _, err := tx.ExecContext(ctx,
+		`DELETE FROM recording_feedback WHERE track_id = ?`, fromId); err != nil {
+		return fmt.Errorf("MergeTracks: delete source feedback: %w", err)
+	}
+
 	if fromRelease != toRelease {
 		// associate fromId's artists with toId's release
 		rows, err := tx.QueryContext(ctx,
diff --git a/internal/db/types.go b/internal/db/types.go
index 46d3c012..33f7fc8d 100644
--- a/internal/db/types.go
+++ b/internal/db/types.go
@@ -55,3 +55,8 @@ type InterestBucket struct {
 	BucketEnd   time.Time `json:"bucket_end"`
 	ListenCount int64     `json:"listen_count"`
 }
+type RecordingFeedback struct {
+	RecordingMBID *uuid.UUID
+	Score         int
+	CreatedAt     int64
+}