diff --git a/internal/backends/dump/dump.go b/internal/backends/dump/dump.go
index 14583f6..1fcd864 100644
--- a/internal/backends/dump/dump.go
+++ b/internal/backends/dump/dump.go
@@ -39,17 +39,16 @@ func (b *DumpBackend) FinishImport() error { return nil }
 
 func (b *DumpBackend) ImportListens(ctx context.Context, export models.ListensResult, importResult models.ImportResult, progress chan models.TransferProgress) (models.ImportResult, error) {
 	for _, listen := range export.Items {
-		select {
-		case <-ctx.Done():
-			return importResult, ctx.Err()
-		default:
-			importResult.UpdateTimestamp(listen.ListenedAt)
-			importResult.ImportCount += 1
-			msg := fmt.Sprintf("🎶 %v: \"%v\" by %v (%v)",
-				listen.ListenedAt, listen.TrackName, listen.ArtistName(), listen.RecordingMBID)
-			importResult.Log(models.Info, msg)
-			progress <- models.TransferProgress{}.FromImportResult(importResult, false)
+		if err := ctx.Err(); err != nil {
+			return importResult, err
 		}
+
+		importResult.UpdateTimestamp(listen.ListenedAt)
+		importResult.ImportCount += 1
+		msg := fmt.Sprintf("🎶 %v: \"%v\" by %v (%v)",
+			listen.ListenedAt, listen.TrackName, listen.ArtistName(), listen.RecordingMBID)
+		importResult.Log(models.Info, msg)
+		progress <- models.TransferProgress{}.FromImportResult(importResult, false)
 	}
 
 	return importResult, nil
@@ -57,17 +56,16 @@ func (b *DumpBackend) ImportListens(ctx context.Context, export models.ListensRe
 
 func (b *DumpBackend) ImportLoves(ctx context.Context, export models.LovesResult, importResult models.ImportResult, progress chan models.TransferProgress) (models.ImportResult, error) {
 	for _, love := range export.Items {
-		select {
-		case <-ctx.Done():
-			return importResult, ctx.Err()
-		default:
-			importResult.UpdateTimestamp(love.Created)
-			importResult.ImportCount += 1
-			msg := fmt.Sprintf("❤️ %v: \"%v\" by %v (%v)",
-				love.Created, love.TrackName, love.ArtistName(), love.RecordingMBID)
-			importResult.Log(models.Info, msg)
-			progress <- models.TransferProgress{}.FromImportResult(importResult, false)
+		if err := ctx.Err(); err != nil {
+			return importResult, err
 		}
+
+		importResult.UpdateTimestamp(love.Created)
+		importResult.ImportCount += 1
+		msg := fmt.Sprintf("❤️ %v: \"%v\" by %v (%v)",
+			love.Created, love.TrackName, love.ArtistName(), love.RecordingMBID)
+		importResult.Log(models.Info, msg)
+		progress <- models.TransferProgress{}.FromImportResult(importResult, false)
 	}
 
 	return importResult, nil
diff --git a/internal/backends/import.go b/internal/backends/import.go
index 3d77b44..e7a6add 100644
--- a/internal/backends/import.go
+++ b/internal/backends/import.go
@@ -106,21 +106,20 @@ func process[R models.LovesResult | models.ListensResult, P ImportProcessor[R]](
 	}
 
 	for exportResult := range results {
-		select {
-		case <-ctx.Done():
+		if err := ctx.Err(); err != nil {
 			processor.ImportBackend().FinishImport()
-			out <- handleError(result, ctx.Err(), progress)
+			out <- handleError(result, err, progress)
 			return
-		default:
-			importResult, err := processor.Import(ctx, exportResult, result, out, progress)
-			result.Update(importResult)
-			if err != nil {
-				processor.ImportBackend().FinishImport()
-				out <- handleError(result, err, progress)
-				return
-			}
-			progress <- p.FromImportResult(result, false)
 		}
+
+		importResult, err := processor.Import(ctx, exportResult, result, out, progress)
+		result.Update(importResult)
+		if err != nil {
+			processor.ImportBackend().FinishImport()
+			out <- handleError(result, err, progress)
+			return
+		}
+		progress <- p.FromImportResult(result, false)
 	}
 
 	if err := processor.ImportBackend().FinishImport(); err != nil {
diff --git a/internal/backends/jspf/jspf.go b/internal/backends/jspf/jspf.go
index a8a1929..354640e 100644
--- a/internal/backends/jspf/jspf.go
+++ b/internal/backends/jspf/jspf.go
@@ -123,15 +123,14 @@ func (b *JSPFBackend) ExportListens(ctx context.Context, oldestTimestamp time.Ti
 
 func (b *JSPFBackend) ImportListens(ctx context.Context, export models.ListensResult, importResult models.ImportResult, progress chan models.TransferProgress) (models.ImportResult, error) {
 	for _, listen := range export.Items {
-		select {
-		case <-ctx.Done():
-			return importResult, ctx.Err()
-		default:
-			track := listenAsTrack(listen)
-			b.playlist.Tracks = append(b.playlist.Tracks, track)
-			importResult.ImportCount += 1
-			importResult.UpdateTimestamp(listen.ListenedAt)
+		if err := ctx.Err(); err != nil {
+			return importResult, err
 		}
+
+		track := listenAsTrack(listen)
+		b.playlist.Tracks = append(b.playlist.Tracks, track)
+		importResult.ImportCount += 1
+		importResult.UpdateTimestamp(listen.ListenedAt)
 	}
 
 	progress <- models.TransferProgress{}.FromImportResult(importResult, false)
@@ -167,15 +166,14 @@ func (b *JSPFBackend) ExportLoves(ctx context.Context, oldestTimestamp time.Time
 
 func (b *JSPFBackend) ImportLoves(ctx context.Context, export models.LovesResult, importResult models.ImportResult, progress chan models.TransferProgress) (models.ImportResult, error) {
 	for _, love := range export.Items {
-		select {
-		case <-ctx.Done():
-			return importResult, ctx.Err()
-		default:
-			track := loveAsTrack(love)
-			b.playlist.Tracks = append(b.playlist.Tracks, track)
-			importResult.ImportCount += 1
-			importResult.UpdateTimestamp(love.Created)
+		if err := ctx.Err(); err != nil {
+			return importResult, err
 		}
+
+		track := loveAsTrack(love)
+		b.playlist.Tracks = append(b.playlist.Tracks, track)
+		importResult.ImportCount += 1
+		importResult.UpdateTimestamp(love.Created)
 	}
 
 	progress <- models.TransferProgress{}.FromImportResult(importResult, false)
diff --git a/internal/backends/lastfm/lastfm.go b/internal/backends/lastfm/lastfm.go
index afc1fa3..b34452e 100644
--- a/internal/backends/lastfm/lastfm.go
+++ b/internal/backends/lastfm/lastfm.go
@@ -103,13 +103,11 @@ func (b *LastfmApiBackend) ExportListens(ctx context.Context, oldestTimestamp ti
 
 out:
 	for page > 0 {
-		select {
-		case <-ctx.Done():
-			results <- models.ListensResult{Error: ctx.Err()}
+		if err := ctx.Err(); err != nil {
+			results <- models.ListensResult{Error: err}
 			p.Export.Abort()
 			progress <- p
 			return
-		default:
 		}
 
 		args := lastfm.P{
@@ -195,10 +193,8 @@ out:
 func (b *LastfmApiBackend) ImportListens(ctx context.Context, export models.ListensResult, importResult models.ImportResult, progress chan models.TransferProgress) (models.ImportResult, error) {
 	total := len(export.Items)
 	for i := 0; i < total; i += MaxListensPerSubmission {
-		select {
-		case <-ctx.Done():
-			return importResult, ctx.Err()
-		default:
+		if err := ctx.Err(); err != nil {
+			return importResult, err
 		}
 
 		listens := export.Items[i:min(i+MaxListensPerSubmission, total)]
@@ -290,13 +286,11 @@ func (b *LastfmApiBackend) ExportLoves(ctx context.Context, oldestTimestamp time
 
 out:
 	for {
-		select {
-		case <-ctx.Done():
-			results <- models.LovesResult{Error: ctx.Err()}
+		if err := ctx.Err(); err != nil {
+			results <- models.LovesResult{Error: err}
 			p.Export.Abort()
 			progress <- p
 			return
-		default:
 		}
 
 		result, err := b.client.User.GetLovedTracks(lastfm.P{
@@ -362,10 +356,8 @@ out:
 
 func (b *LastfmApiBackend) ImportLoves(ctx context.Context, export models.LovesResult, importResult models.ImportResult, progress chan models.TransferProgress) (models.ImportResult, error) {
 	for _, love := range export.Items {
-		select {
-		case <-ctx.Done():
-			return importResult, ctx.Err()
-		default:
+		if err := ctx.Err(); err != nil {
+			return importResult, err
 		}
 
 		err := b.client.Track.Love(lastfm.P{
diff --git a/internal/backends/spotifyhistory/spotifyhistory.go b/internal/backends/spotifyhistory/spotifyhistory.go
index 9a1ab2b..76d0c9e 100644
--- a/internal/backends/spotifyhistory/spotifyhistory.go
+++ b/internal/backends/spotifyhistory/spotifyhistory.go
@@ -90,13 +90,11 @@ func (b *SpotifyHistoryBackend) ExportListens(ctx context.Context, oldestTimesta
 	fileCount := int64(len(files))
 	p.Export.Total = fileCount
 	for i, filePath := range files {
-		select {
-		case <-ctx.Done():
-			results <- models.ListensResult{Error: ctx.Err()}
+		if err := ctx.Err(); err != nil {
+			results <- models.ListensResult{Error: err}
 			p.Export.Abort()
 			progress <- p
 			return
-		default:
 		}
 
 		history, err := readHistoryFile(filePath)