diff --git a/Dockerfile b/Dockerfile
index d2c989f..9a0bf10 100644
--- a/Dockerfile
+++ b/Dockerfile
@@ -26,7 +26,9 @@ COPY web/tv/*.go web/tv/
 COPY web/tv/*.html web/tv/
 COPY web/settings/*.go web/settings/
 COPY web/settings/*.html web/settings/
-COPY web/server.go web/index.html web/static/ /web/
+COPY web/server.go web/
+COPY web/index.html web/
+COPY web/static/ web/static/
 
 # Build
 RUN CGO_ENABLED=0 GOOS=linux go build -o /plex-lookup
diff --git a/TODO b/TODO
index 09cc378..ebffa9b 100644
--- a/TODO
+++ b/TODO
@@ -2,13 +2,13 @@
 
 ## features
 
-- similar artist search for music
-
 ## bugs
 
+- allow amazon tv search for indivdual series
 - allow amazon tv search for newer series
 - update movies to use tv like search
-- allow amazon tv search for indivdual series
+- update movies, remove the plex resolution filter add plex resolution as a column
+- music, a-ha/ash doesnt match as an artist why ?
 
 ## done
 
@@ -28,3 +28,5 @@
 - remove dead fields from the tv data types
 - remove links to tv series we already have in plex. eg dont show adventure time series 1 and 2 ?
 - write a function to calculate plex dates
+- similar artist search for music
+- parallel requests for spotify search
diff --git a/musicbrainz/musicbrainz.go b/musicbrainz/musicbrainz.go
index afd40d8..09d14ca 100644
--- a/musicbrainz/musicbrainz.go
+++ b/musicbrainz/musicbrainz.go
@@ -68,7 +68,7 @@ func SearchMusicBrainzArtist(plexArtist *types.PlexMusicArtist) (artist types.Se
 		if resp.Artists[i].Name != plexArtist.Name {
 			continue
 		}
-		found := types.MusicSearchResult{
+		found := types.MusicArtistSearchResult{
 			Name: resp.Artists[i].Name,
 			ID:   fmt.Sprintf("%v", resp.Artists[i].ID),
 		}
@@ -85,7 +85,7 @@ func SearchMusicBrainzArtist(plexArtist *types.PlexMusicArtist) (artist types.Se
 	return artist, err
 }
 
-func SearchMusicBrainzAlbums(artistID string) (albums []types.MusicSearchAlbumResult, err error) {
+func SearchMusicBrainzAlbums(artistID string) (albums []types.MusicAlbumSearchResult, err error) {
 	client, err := gomusicbrainz.NewWS2Client(
 		musicBrainzURL, agent, agentVersion, "")
 
@@ -106,7 +106,7 @@ func SearchMusicBrainzAlbums(artistID string) (albums []types.MusicSearchAlbumRe
 	for i := range resp.ReleaseGroups {
 		if resp.ReleaseGroups[i].Type == "Album" {
 			year := resp.ReleaseGroups[i].FirstReleaseDate.Year()
-			albums = append(albums, types.MusicSearchAlbumResult{
+			albums = append(albums, types.MusicAlbumSearchResult{
 				Title: resp.ReleaseGroups[i].Title,
 				ID:    fmt.Sprintf("%v", resp.ReleaseGroups[i].ID),
 				Year:  fmt.Sprintf("%v", year),
diff --git a/musicbrainz/musicbrainz_test.go b/musicbrainz/musicbrainz_test.go
index 71a18fa..89867f6 100644
--- a/musicbrainz/musicbrainz_test.go
+++ b/musicbrainz/musicbrainz_test.go
@@ -18,12 +18,12 @@ func TestSearchMusicBrainzArtist(t *testing.T) {
 			args: &types.PlexMusicArtist{Name: "The Beatles"},
 			wantArtist: types.SearchResults{
 				SearchURL: "https://musicbrainz.org/artist/b10bbbfc-cf9e-42e0-be17-e2c3e1d2600d",
-				MusicSearchResults: []types.MusicSearchResult{
+				MusicSearchResults: []types.MusicArtistSearchResult{
 
 					{
 						Name:   "The Beatles",
 						ID:     "b10bbbfc-cf9e-42e0-be17-e2c3e1d2600d",
-						Albums: make([]types.MusicSearchAlbumResult, 16),
+						Albums: make([]types.MusicAlbumSearchResult, 16),
 					},
 				},
 			},
@@ -34,11 +34,11 @@ func TestSearchMusicBrainzArtist(t *testing.T) {
 			args: &types.PlexMusicArtist{Name: "AC/DC"},
 			wantArtist: types.SearchResults{
 				SearchURL: "https://musicbrainz.org/artist/66c662b6-6e2f-4930-8610-912e24c63ed1",
-				MusicSearchResults: []types.MusicSearchResult{
+				MusicSearchResults: []types.MusicArtistSearchResult{
 					{
 						Name:   "AC/DC",
 						ID:     "66c662b6-6e2f-4930-8610-912e24c63ed1",
-						Albums: make([]types.MusicSearchAlbumResult, 18),
+						Albums: make([]types.MusicAlbumSearchResult, 17),
 					},
 				},
 			},
diff --git a/spotify/spotify.go b/spotify/spotify.go
index acd7fb4..c055cf5 100644
--- a/spotify/spotify.go
+++ b/spotify/spotify.go
@@ -7,6 +7,7 @@ import (
 	"io"
 	"net/http"
 	"net/url"
+	"strconv"
 	"strings"
 	"time"
 
@@ -93,44 +94,72 @@ type AlbumsResponse struct {
 	Total    int64 `json:"total"`
 }
 
-func SearchSpotifyArtist(plexArtist *types.PlexMusicArtist, clientID, clientSecret string) (artist types.SearchResults, err error) {
-	artist.PlexMusicArtist = *plexArtist
+type SimilarArtistsResponse struct {
+	Artists []struct {
+		Name string `json:"name"`
+		ID   string `json:"id"`
+	}
+}
+
+func SearchSpotifyArtist(plexArtist *types.PlexMusicArtist, clientID, clientSecret string, ch chan<- *types.SearchResults) {
+	// context with a timeout of 30 seconds
+	ctx, cancel := context.WithTimeout(context.Background(), time.Second*time.Duration(lookupTimeout))
+	defer cancel()
+	searchResults := types.SearchResults{}
+	searchResults.PlexMusicArtist = *plexArtist
 	// get oauth token
-	if oauthToken == "" {
-		oauthToken, err = spotifyOauthToken(context.Background(), clientID, clientSecret)
-		if err != nil {
-			return artist, fmt.Errorf("SearchSpotifyArtist: unable to get oauth token: %s", err.Error())
-		}
+	err := SpotifyOauthToken(ctx, clientID, clientSecret)
+	if err != nil {
+		fmt.Printf("SearchSpotifyArtist: unable to get oauth token: %s\n", err.Error())
+		ch <- &searchResults
+		return
 	}
 	urlEncodedArtist := url.QueryEscape(plexArtist.Name)
 	artistURL := fmt.Sprintf("%s/search?q=%s&type=artist&limit=10", spotifyAPIURL, urlEncodedArtist)
 	client := &http.Client{
 		Timeout: time.Second * lookupTimeout,
 	}
-	req, _ := http.NewRequestWithContext(context.Background(), http.MethodGet, artistURL, http.NoBody)
+	req, _ := http.NewRequestWithContext(ctx, http.MethodGet, artistURL, http.NoBody)
 	bearer := fmt.Sprintf("Bearer %s", oauthToken)
 	req.Header.Add("Authorization", bearer)
-	response, err := client.Do(req)
-	if err != nil {
-		return artist, fmt.Errorf("lookupArtist: get failed from spotify: %s", err.Error())
-	}
-	if response.StatusCode == http.StatusTooManyRequests {
-		return artist, fmt.Errorf("lookupArtist: rate limited by spotify")
+	var response *http.Response
+	for {
+		response, err = client.Do(req)
+		if err != nil {
+			response.Body.Close()
+			fmt.Printf("lookupArtist: get failed from spotify: %s\n", err.Error())
+			ch <- &searchResults
+			return
+		}
+		if response.StatusCode == http.StatusTooManyRequests {
+			// rate limited
+			wait := response.Header.Get("Retry-After")
+			waitSeconds, _ := strconv.Atoi(wait)
+			time.Sleep(time.Duration(waitSeconds) * time.Second)
+			continue
+		}
+		if response.StatusCode == http.StatusOK {
+			break
+		}
 	}
 	defer response.Body.Close()
 	body, err := io.ReadAll(response.Body)
 	if err != nil {
-		return artist, fmt.Errorf("lookupArtist: unable to parse response from spotify: %s", err.Error())
+		fmt.Printf("lookupArtist: unable to read response from spotify: %s\n", err.Error())
+		ch <- &searchResults
+		return
 	}
 	var artistResponse ArtistResponse
 	jsonErr := json.Unmarshal(body, &artistResponse)
 	if jsonErr != nil {
-		return artist, fmt.Errorf("lookupArtist: unable to parse response from spotify: %s", jsonErr.Error())
+		fmt.Printf("lookupArtist: unable to parse response from spotify: %s\n", jsonErr.Error())
+		ch <- &searchResults
+		return
 	}
 	for i := range artistResponse.Artists.Items {
 		if artistStringMatcher(plexArtist.Name, artistResponse.Artists.Items[i].Name) {
 			// only get the first match
-			artist.MusicSearchResults = append(artist.MusicSearchResults, types.MusicSearchResult{
+			searchResults.MusicSearchResults = append(searchResults.MusicSearchResults, types.MusicArtistSearchResult{
 				Name: artistResponse.Artists.Items[i].Name,
 				ID:   artistResponse.Artists.Items[i].ID,
 				URL:  artistResponse.Artists.Items[i].ExternalUrls.Spotify,
@@ -139,44 +168,67 @@ func SearchSpotifyArtist(plexArtist *types.PlexMusicArtist, clientID, clientSecr
 			break
 		}
 	}
-	if len(artist.MusicSearchResults) == 0 {
-		return artist, err
-	}
-	// get the albums
-	artist.MusicSearchResults[0].Albums, err = SearchSpotifyAlbums(artist.MusicSearchResults[0].ID, clientID, clientSecret)
-	return artist, nil
+	ch <- &searchResults
 }
 
-func SearchSpotifyAlbums(artistID, clientID, clientSecret string) (albums []types.MusicSearchAlbumResult, err error) {
-	if oauthToken == "" {
-		oauthToken, err = spotifyOauthToken(context.Background(), clientID, clientSecret)
-		if err != nil {
-			return albums, fmt.Errorf("SearchSpotifyAlbums: unable to get oauth token: %s", err.Error())
-		}
+func SearchSpotifyAlbum(m *types.SearchResults, clientID, clientSecret string, ch chan<- *types.SearchResults) {
+	// get oauth token
+	err := SpotifyOauthToken(context.Background(), clientID, clientSecret)
+	if err != nil {
+		fmt.Printf("SearchSpotifyAlbums: unable to get oauth token: %s\n", err.Error())
+		ch <- m
+		return
+	}
+	if len(m.MusicSearchResults) == 0 {
+		// no artist found for the plex artist
+		fmt.Printf("SearchSpotifyAlbums: no artist found for %s\n", m.PlexMusicArtist.Name)
+		ch <- m
+		return
 	}
-	albumURL := fmt.Sprintf("%s/artists/%s/albums?include_groups=album&limit=50&", spotifyAPIURL, artistID)
+	albumURL := fmt.Sprintf("%s/artists/%s/albums?include_groups=album&limit=50&", spotifyAPIURL, m.MusicSearchResults[0].ID)
 	client := &http.Client{
 		Timeout: time.Second * lookupTimeout,
 	}
 	req, _ := http.NewRequestWithContext(context.Background(), http.MethodGet, albumURL, http.NoBody)
 	bearer := fmt.Sprintf("Bearer %s", oauthToken)
 	req.Header.Add("Authorization", bearer)
-	response, err := client.Do(req)
-	if err != nil {
-		return albums, fmt.Errorf("lookupArtistAlbums: get failed from spotify: %s", err.Error())
+	var response *http.Response
+	for {
+		response, err = client.Do(req)
+		if err != nil {
+			response.Body.Close()
+			fmt.Printf("lookupArtistAlbums: get failed from spotify: %s\n", err.Error())
+			ch <- m
+			return
+		}
+		if response.StatusCode == http.StatusTooManyRequests {
+			wait := response.Header.Get("Retry-After")
+			waitSeconds, _ := strconv.Atoi(wait)
+			if waitSeconds > lookupTimeout {
+				fmt.Printf("lookupArtistAlbums: rate limited for %d seconds\n", waitSeconds)
+			}
+			time.Sleep(time.Duration(waitSeconds) * time.Second)
+			continue
+		}
+		if response.StatusCode == http.StatusOK {
+			break
+		}
 	}
 	defer response.Body.Close()
 	body, err := io.ReadAll(response.Body)
 	if err != nil {
-		return albums, fmt.Errorf("lookupArtistAlbums: unable to parse response from spotify: %s", err.Error())
+		fmt.Printf("lookupArtistAlbums: unable to parse response from spotify: %s\n", err.Error())
+		ch <- m
+		return
 	}
 	var albumsResponse AlbumsResponse
 	_ = json.Unmarshal(body, &albumsResponse)
 
+	albums := make([]types.MusicAlbumSearchResult, 0)
 	for i := range albumsResponse.Items {
 		// convert "2022-06-03" to "2022"
 		year := strings.Split(albumsResponse.Items[i].ReleaseDate, "-")[0]
-		albums = append(albums, types.MusicSearchAlbumResult{
+		albums = append(albums, types.MusicAlbumSearchResult{
 			Title: albumsResponse.Items[i].Name,
 			ID:    albumsResponse.Items[i].ID,
 			URL:   albumsResponse.Items[i].ExternalUrls.Spotify,
@@ -184,12 +236,81 @@ func SearchSpotifyAlbums(artistID, clientID, clientSecret string) (albums []type
 		})
 	}
 
-	return albums, err
+	m.MusicSearchResults[0].Albums = albums
+	ch <- m
+}
+
+func SearchSpotifySimilarArtist(m *types.SearchResults, clientID, clientSecret string, ch chan<- SimilarArtistsResponse) {
+	err := SpotifyOauthToken(context.Background(), clientID, clientSecret)
+	if err != nil {
+		fmt.Printf("SearchSpotifySimilarArtist: unable to get oauth token: %s\n", err.Error())
+		ch <- SimilarArtistsResponse{}
+		return
+	}
+	if len(m.MusicSearchResults) == 0 {
+		// no artist found for the plex artist
+		fmt.Printf("SearchSpotifySimilarArtist: no artist found for %s\n", m.PlexMusicArtist.Name)
+		ch <- SimilarArtistsResponse{}
+		return
+	}
+	similarArtistURL := fmt.Sprintf("%s/artists/%s/related-artists", spotifyAPIURL, m.MusicSearchResults[0].ID)
+	client := &http.Client{
+		Timeout: time.Second * lookupTimeout,
+	}
+	req, httpErr := http.NewRequestWithContext(context.Background(), http.MethodGet, similarArtistURL, http.NoBody)
+	if httpErr != nil {
+		fmt.Printf("SearchSpotifySimilarArtist: get failed from spotify: %s\n", httpErr.Error())
+		ch <- SimilarArtistsResponse{}
+		return
+	}
+	bearer := fmt.Sprintf("Bearer %s", oauthToken)
+	req.Header.Add("Authorization", bearer)
+	var response *http.Response
+	for {
+		response, err = client.Do(req)
+		if err != nil {
+			response.Body.Close()
+			fmt.Printf("SearchSpotifySimilarArtist: get failed from spotify: %s\n", err.Error())
+			ch <- SimilarArtistsResponse{}
+			return
+		}
+		if response.StatusCode == http.StatusTooManyRequests {
+			wait := response.Header.Get("Retry-After")
+			waitSeconds, _ := strconv.Atoi(wait)
+			if waitSeconds > lookupTimeout {
+				fmt.Printf("SearchSpotifySimilarArtist: rate limited for %d seconds\n", waitSeconds)
+			}
+			time.Sleep(time.Duration(waitSeconds) * time.Second)
+			continue
+		}
+		if response.StatusCode == http.StatusOK {
+			break
+		}
+	}
+
+	defer response.Body.Close()
+	body, err := io.ReadAll(response.Body)
+	if err != nil {
+		fmt.Printf("SearchSpotifySimilarArtist: unable to parse response from spotify: %s\n", err.Error())
+		ch <- SimilarArtistsResponse{}
+		return
+	}
+	var similarArtistsResponse SimilarArtistsResponse
+	jsonErr := json.Unmarshal(body, &similarArtistsResponse)
+	if jsonErr != nil {
+		fmt.Printf("SearchSpotifySimilarArtist: unable to unmarshal response from spotify: %s\n", jsonErr.Error())
+		ch <- SimilarArtistsResponse{}
+		return
+	}
+	ch <- similarArtistsResponse
 }
 
 // function that gets an oauth token from spotify from the client id and secret
-func spotifyOauthToken(ctx context.Context, clientID, clientSecret string) (oauth string, err error) {
+func SpotifyOauthToken(ctx context.Context, clientID, clientSecret string) (err error) {
 	// get oauth token
+	if oauthToken != "" {
+		return nil
+	}
 	oauthURL := "https://accounts.spotify.com/api/token"
 	client := &http.Client{
 		Timeout: time.Second * lookupTimeout,
@@ -202,12 +323,12 @@ func spotifyOauthToken(ctx context.Context, clientID, clientSecret string) (oaut
 	req.Header.Add("Content-Type", "application/x-www-form-urlencoded")
 	response, err := client.Do(req)
 	if err != nil {
-		return "", fmt.Errorf("spotifyOauthToken: get failed from spotify: %s", err.Error())
+		return fmt.Errorf("spotifyOauthToken: get failed from spotify: %s", err.Error())
 	}
 	defer response.Body.Close()
 	body, err := io.ReadAll(response.Body)
 	if err != nil {
-		return "", fmt.Errorf("spotifyOauthToken: unable to read response from spotify: %s", err.Error())
+		return fmt.Errorf("spotifyOauthToken: unable to read response from spotify: %s", err.Error())
 	}
 	var oauthResponse struct {
 		AccessToken string `json:"access_token"`
@@ -215,9 +336,10 @@ func spotifyOauthToken(ctx context.Context, clientID, clientSecret string) (oaut
 	}
 	err = json.Unmarshal(body, &oauthResponse)
 	if err != nil {
-		return "", fmt.Errorf("getOauthToken: unable to parse response from spotify: %s", err.Error())
+		return fmt.Errorf("getOauthToken: unable to parse response from spotify: %s", err.Error())
 	}
-	return oauthResponse.AccessToken, nil
+	oauthToken = oauthResponse.AccessToken
+	return nil
 }
 
 func artistStringMatcher(dbName, webName string) bool {
diff --git a/spotify/spotify_test.go b/spotify/spotify_test.go
index 8e6e5fe..a3647c1 100644
--- a/spotify/spotify_test.go
+++ b/spotify/spotify_test.go
@@ -16,84 +16,46 @@ func TestSearchSpotifyArtist(t *testing.T) {
 	if spotifyClientID == "" || spotifyClientSecret == "" {
 		t.Skip("SPOTIFY_CLIENT_ID and SPOTIFY_CLIENT_SECRET not set")
 	}
-	tests := []struct {
-		name       string
-		args       *types.PlexMusicArtist
-		wantArtist types.SearchResults
-		wantErr    bool
-	}{
-		{
-			name: "artist exists",
-			args: &types.PlexMusicArtist{Name: "The Beatles"},
-			wantArtist: types.SearchResults{
-				SearchURL: "https://open.spotify.com/artist/711MCceyCBcFnzjGY4Q7Un",
-				MusicSearchResults: []types.MusicSearchResult{
-					{
-						Name:   "The Beatles",
-						ID:     "b10bbbfc-cf9e-42e0-be17-e2c3e1d2600d",
-						Albums: make([]types.MusicSearchAlbumResult, 27),
-					},
-				},
-			},
-			wantErr: false,
-		},
-		{
-			name: "artist has special characters",
-			args: &types.PlexMusicArtist{Name: "AC/DC"},
-			wantArtist: types.SearchResults{
-				SearchURL: "https://open.spotify.com/artist/711MCceyCBcFnzjGY4Q7Un",
-				MusicSearchResults: []types.MusicSearchResult{
-					{
-						Name:   "AC/DC",
-						ID:     "711MCceyCBcFnzjGY4Q7Un",
-						Albums: make([]types.MusicSearchAlbumResult, 21),
-					},
-				},
-			},
-			wantErr: false,
-		},
+
+	plexArtist := &types.PlexMusicArtist{Name: "The Beatles"}
+
+	ch := make(chan *types.SearchResults, 1)
+	SearchSpotifyArtist(plexArtist, spotifyClientID, spotifyClientSecret, ch)
+
+	got := <-ch
+	if len(got.MusicSearchResults) != 1 {
+		t.Errorf("SearchSpotifyArtist() returned %d results, expected 1", len(got.MusicSearchResults))
 	}
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			gotArtist, err := SearchSpotifyArtist(tt.args, spotifyClientID, spotifyClientSecret)
-			if (err != nil) != tt.wantErr {
-				t.Errorf("SearchSpotifyArtist() error = %v, wantErr %v", err, tt.wantErr)
-				return
-			}
-			if gotArtist.MusicSearchResults[0].Name != tt.wantArtist.MusicSearchResults[0].Name {
-				t.Errorf("SearchSpotifyArtist() Name = %v, want %v", gotArtist, tt.wantArtist)
-			}
-			if len(gotArtist.MusicSearchResults[0].Albums) != len(tt.wantArtist.MusicSearchResults[0].Albums) {
-				t.Errorf("SearchSpotifyArtist() Albums size = %v, want %v",
-					len(gotArtist.MusicSearchResults[0].Albums), len(tt.wantArtist.MusicSearchResults[0].Albums))
-			}
-		})
+
+	expectedArtist := types.MusicArtistSearchResult{
+		Name: "The Beatles",
+		ID:   "3WrFJ7ztbogyGnTHbHJFl2",
+		URL:  "https://open.spotify.com/artist/3WrFJ7ztbogyGnTHbHJFl2",
 	}
-}
 
-// debug test for individual artists
-func TestSearchSpotifyArtistDebug(t *testing.T) {
-	if spotifyClientID == "" || spotifyClientSecret == "" {
-		t.Skip("SPOTIFY_CLIENT_ID and SPOTIFY_CLIENT_SECRET not set")
+	if got.MusicSearchResults[0].Name != expectedArtist.Name {
+		t.Errorf("SearchSpotifyArtist() returned %s, expected %s", got.MusicSearchResults[0].Name, expectedArtist.Name)
+	}
+	if got.MusicSearchResults[0].ID != expectedArtist.ID {
+		t.Errorf("SearchSpotifyArtist() returned %s, expected %s", got.MusicSearchResults[0].ID, expectedArtist.ID)
 	}
-	artist := &types.PlexMusicArtist{Name: "Angel Olsen"}
-	artistSearchResult, err := SearchSpotifyArtist(artist, spotifyClientID, spotifyClientSecret)
-	if err != nil {
-		t.Errorf("SearchSpotifyArtist() error = %v", err)
+	if got.MusicSearchResults[0].URL != expectedArtist.URL {
+		t.Errorf("SearchSpotifyArtist() returned %s, expected %s", got.MusicSearchResults[0].URL, expectedArtist.URL)
 	}
-	t.Logf("SearchSpotifyArtist() = %v", artistSearchResult)
 }
 
-func TestSearchSpotifyAlbumsDebug(t *testing.T) {
+// debug test for individual artists
+func TestSearchSpotifyArtistDebug(t *testing.T) {
 	if spotifyClientID == "" || spotifyClientSecret == "" {
 		t.Skip("SPOTIFY_CLIENT_ID and SPOTIFY_CLIENT_SECRET not set")
 	}
-	artistID := "6mKqFxGMS5TGDZI3XkT5Rt"
-	artistSearchResult, err := SearchSpotifyAlbums(artistID, spotifyClientID, spotifyClientSecret)
-	if err != nil {
-		t.Errorf("SearchSpotifyAlbum() error = %v", err)
-	}
-	t.Logf("SearchSpotifyAlbum() = %v", artistSearchResult)
+	plexArtist := &types.PlexMusicArtist{Name: "Angel Olsen"}
+
+	ch := make(chan *types.SearchResults, 1)
+	SearchSpotifyArtist(plexArtist, spotifyClientID, spotifyClientSecret, ch)
+
+	got := <-ch
+	t.Logf("SearchSpotifyArtist() = %+v", got)
 }
 
 func TestSearchSpotifyAlbums(t *testing.T) {
@@ -101,7 +63,7 @@ func TestSearchSpotifyAlbums(t *testing.T) {
 		t.Skip("SPOTIFY_CLIENT_ID and SPOTIFY_CLIENT_SECRET not set")
 	}
 	type args struct {
-		artistID string
+		m *types.SearchResults
 	}
 	tests := []struct {
 		name       string
@@ -111,20 +73,69 @@ func TestSearchSpotifyAlbums(t *testing.T) {
 	}{
 		{
 			name:       "albums exist",
-			args:       args{artistID: "711MCceyCBcFnzjGY4Q7Un"},
+			args:       args{m: &types.SearchResults{MusicSearchResults: []types.MusicArtistSearchResult{{ID: "711MCceyCBcFnzjGY4Q7Un"}}}},
 			albumCount: 21,
 			wantErr:    false,
 		},
 	}
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
-			gotAlbums, err := SearchSpotifyAlbums(tt.args.artistID, spotifyClientID, spotifyClientSecret)
-			if (err != nil) != tt.wantErr {
-				t.Errorf("SearchSpotifyAlbums() error = %v, wantErr %v", err, tt.wantErr)
-				return
+			ch := make(chan *types.SearchResults, 1)
+			SearchSpotifyAlbum(tt.args.m, spotifyClientID, spotifyClientSecret, ch)
+			got := <-ch
+
+			if len(got.MusicSearchResults[0].Albums) != tt.albumCount {
+				t.Errorf("SearchSpotifyAlbums() = %v, want %v", len(got.MusicSearchResults[0].Albums), tt.albumCount)
 			}
-			if len(gotAlbums) != tt.albumCount {
-				t.Errorf("SearchSpotifyAlbums() = %v, want %v", len(gotAlbums), tt.albumCount)
+		})
+	}
+}
+
+func TestSearchSpotifyAlbumsDebug(t *testing.T) {
+	if spotifyClientID == "" || spotifyClientSecret == "" {
+		t.Skip("SPOTIFY_CLIENT_ID and SPOTIFY_CLIENT_SECRET not set")
+	}
+	want := types.SearchResults{
+		MusicSearchResults: []types.MusicArtistSearchResult{
+			{
+				Name: "",
+				ID:   "16GcWuvvybAoaHr0NqT8Eh",
+				URL:  "",
+			},
+		},
+	}
+	ch := make(chan *types.SearchResults, 1)
+	SearchSpotifyAlbum(&want, spotifyClientID, spotifyClientSecret, ch)
+	got := <-ch
+
+	t.Logf("SearchSpotifyAlbum() = %v", got.MusicSearchResults)
+}
+
+func TestSpotifyLookupSimilarArtists(t *testing.T) {
+	if spotifyClientID == "" || spotifyClientSecret == "" {
+		t.Skip("SPOTIFY_CLIENT_ID and SPOTIFY_CLIENT_SECRET not set")
+	}
+	tests := []struct {
+		name         string
+		searchResult types.SearchResults
+		wantErr      bool
+		wantLength   int
+	}{
+		{
+			name:         "similar artists exist",
+			searchResult: types.SearchResults{MusicSearchResults: []types.MusicArtistSearchResult{{ID: "711MCceyCBcFnzjGY4Q7Un"}}},
+			wantErr:      false,
+			wantLength:   20,
+		},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			ch := make(chan SimilarArtistsResponse, 1)
+			searchResult := tt.searchResult // Create a local variable to avoid implicit memory aliasing
+			SearchSpotifySimilarArtist(&searchResult, spotifyClientID, spotifyClientSecret, ch)
+			got := <-ch
+			if len(got.Artists) != tt.wantLength {
+				t.Errorf("SpotifyLookupSimilarArtists() = %v, want %v", len(got.Artists), tt.wantLength)
 			}
 		})
 	}
diff --git a/types/types.go b/types/types.go
index 69fa540..b8b2306 100644
--- a/types/types.go
+++ b/types/types.go
@@ -27,7 +27,7 @@ type SearchResults struct {
 	MatchesBluray      int
 	MovieSearchResults []MovieSearchResult
 	TVSearchResults    []TVSearchResult
-	MusicSearchResults []MusicSearchResult
+	MusicSearchResults []MusicArtistSearchResult
 }
 
 type Configuration struct {
@@ -123,20 +123,28 @@ type PlexMusicAlbum struct {
 	DateAdded time.Time
 }
 
-type MusicSearchResult struct {
-	Name   string
-	ID     string
-	URL    string
-	Albums []MusicSearchAlbumResult
+type MusicArtistSearchResult struct {
+	Name        string
+	ID          string
+	URL         string
+	OwnedAlbums int
+	Albums      []MusicAlbumSearchResult
 }
 
-type MusicSearchAlbumResult struct {
+type MusicAlbumSearchResult struct {
 	Title string
 	ID    string
 	URL   string
 	Year  string
 }
 
+type MusicSimilarArtistResult struct {
+	Name            string
+	URL             string
+	Owned           bool
+	SimilarityCount int
+}
+
 // ==============================================================================================================
 type PlexLibrary struct {
 	Title string
diff --git a/web/music/music.go b/web/music/music.go
index 5fd0c43..38543e8 100644
--- a/web/music/music.go
+++ b/web/music/music.go
@@ -22,9 +22,14 @@ var (
 	numberOfArtistsProcessed int  = 0
 	artistsJobRunning        bool = false
 	totalArtists             int  = 0
-	plexMusic                []types.PlexMusicArtist
-	artistsSearchResults     []types.SearchResults
-	albumReleaseYearCutoff   int = 5
+
+	plexMusic              []types.PlexMusicArtist
+	artistsSearchResults   []types.SearchResults
+	similarArtistsResults  map[string]types.MusicSimilarArtistResult
+	lookup                 string
+	lookupType             string
+	spotifyThreads         int = 2
+	albumReleaseYearCutoff int = 5
 )
 
 type MusicConfig struct {
@@ -42,8 +47,8 @@ func MusicHandler(w http.ResponseWriter, _ *http.Request) {
 
 // nolint: lll, nolintlint
 func (c MusicConfig) ProcessHTML(w http.ResponseWriter, r *http.Request) {
-	lookup := r.FormValue("lookup")
-	lookupType := r.FormValue("lookuptype")
+	lookup = r.FormValue("lookup")
+	lookupType = r.FormValue("lookuptype")
 	// only get the artists from plex once
 	if len(plexMusic) == 0 {
 		plexMusic = plex.GetPlexMusicArtists(c.Config.PlexIP, c.Config.PlexMusicLibraryID, c.Config.PlexToken)
@@ -61,35 +66,41 @@ func (c MusicConfig) ProcessHTML(w http.ResponseWriter, r *http.Request) {
 		case "musicbrainz":
 			go func() {
 				startTime := time.Now()
+				totalArtists = 49
 				for i := 0; i < 50; i++ {
 					fmt.Print(".")
 					searchResult, _ = musicbrainz.SearchMusicBrainzArtist(&plexMusic[i])
 					artistsSearchResults = append(artistsSearchResults, searchResult)
 					numberOfArtistsProcessed = i
 				}
+				totalArtists = numberOfArtistsProcessed
 				artistsJobRunning = false
 				fmt.Printf("Processed %d artists in %v\n", numberOfArtistsProcessed, time.Since(startTime))
 			}()
 		default:
 			// search spotify
 			go func() {
-				startTime := time.Now()
-				for i := range plexMusic {
-					fmt.Print(".")
-					searchResult, _ = spotify.SearchSpotifyArtist(&plexMusic[i], c.Config.SpotifyClientID, c.Config.SpotifyClientSecret)
-					artistsSearchResults = append(artistsSearchResults, searchResult)
-					numberOfArtistsProcessed = i
-				}
+				getSpotifyArtistsInParallel(c.Config.SpotifyClientID, c.Config.SpotifyClientSecret)
+				numberOfArtistsProcessed = 0
+				getSpotifyAlbumsInParallel(c.Config.SpotifyClientID, c.Config.SpotifyClientSecret)
+				totalArtists = numberOfArtistsProcessed
 				artistsJobRunning = false
-				fmt.Printf("Processed %d artists in %v\n", numberOfArtistsProcessed, time.Since(startTime))
 			}()
 		}
 	} else {
-		fmt.Println("Processing new artists")
-		fmt.Printf("running %v\n", artistsJobRunning)
-		time.Sleep(1 * time.Second)
-		artistsJobRunning = false
-		fmt.Println(searchResult)
+		switch lookup {
+		case "spotify":
+			go func() {
+				getSpotifyArtistsInParallel(c.Config.SpotifyClientID, c.Config.SpotifyClientSecret)
+				numberOfArtistsProcessed = 0
+				getSpotifySimilarArtistsInParallel(c.Config.SpotifyClientID, c.Config.SpotifyClientSecret)
+				totalArtists = numberOfArtistsProcessed
+				artistsJobRunning = false
+			}()
+			fmt.Println("Searching Spotify for similar artists")
+		default:
+			fmt.Fprintf(w, `<div class="alert alert-danger" role="alert">Similar Artist search is not available for this lookup provider</div>`)
+		}
 	}
 }
 
@@ -97,27 +108,135 @@ func ProgressBarHTML(w http.ResponseWriter, _ *http.Request) {
 	if artistsJobRunning {
 		fmt.Fprintf(w, `<div hx-get="/musicprogress" hx-trigger="every 100ms" class="container" id="progress" hx-swap="outerHTML">
 		<progress value="%d" max= "%d"/></div>`, numberOfArtistsProcessed, totalArtists)
-	}
-	if totalArtists == numberOfArtistsProcessed && totalArtists != 0 {
+	} else if totalArtists == numberOfArtistsProcessed && totalArtists != 0 {
+		tableContents := ""
+		if lookupType == "missingalbums" {
+			tableContents = renderArtistAlbumsTable()
+		} else {
+			tableContents = renderSimilarArtistsTable()
+		}
 		fmt.Fprintf(w,
 			`<table class="table-sortable">%s</tbody></table>
 		</script><script>document.querySelector('.table-sortable').tsortable()</script>`,
-			renderArtistsTable(artistsSearchResults))
+			tableContents)
 		// reset variables
 		numberOfArtistsProcessed = 0
 		totalArtists = 0
-		artistsSearchResults = []types.SearchResults{}
 	}
 }
 
-func renderArtistsTable(searchResults []types.SearchResults) (tableRows string) {
-	searchResults = filterMusicSearchResults(searchResults)
-	tableRows = `<thead><tr><th data-sort="string"><strong>Plex Artist</strong></th><th data-sort="int"><strong>Albums</strong></th><th><strong>Album</strong></th></tr></thead><tbody>` //nolint: lll
+func getSpotifyArtistsInParallel(id, token string) {
+	startTime := time.Now()
+	ch := make(chan *types.SearchResults, len(plexMusic))
+	semaphore := make(chan struct{}, spotifyThreads)
+	for i := range len(plexMusic) {
+		go func(i int) {
+			semaphore <- struct{}{}
+			defer func() { <-semaphore }()
+			spotify.SearchSpotifyArtist(&plexMusic[i], id, token, ch)
+		}(i)
+	}
+	// gather results
+	artistsSearchResults = make([]types.SearchResults, 0)
+	for range len(plexMusic) {
+		result := <-ch
+		artistsSearchResults = append(artistsSearchResults, *result)
+		fmt.Print(".")
+		numberOfArtistsProcessed++
+	}
+	fmt.Printf("Processed %d artists in %v\n", len(plexMusic), time.Since(startTime))
+}
+
+func getSpotifyAlbumsInParallel(id, token string) {
+	fmt.Println("Searching Spotify for artist albums")
+	startTime := time.Now()
+	ch := make(chan *types.SearchResults, len(artistsSearchResults))
+	semaphore := make(chan struct{}, spotifyThreads)
+	for i := range artistsSearchResults {
+		go func(i int) {
+			semaphore <- struct{}{}
+			defer func() { <-semaphore }()
+			spotify.SearchSpotifyAlbum(&artistsSearchResults[i], id, token, ch)
+		}(i)
+	}
+	// gather results
+	bla := make([]types.SearchResults, 0)
+	for range artistsSearchResults {
+		result := <-ch
+		bla = append(bla, *result)
+		fmt.Print(".")
+		numberOfArtistsProcessed++
+	}
+	artistsSearchResults = bla
+	fmt.Printf("Processed %d artists in %v", len(bla), time.Since(startTime))
+}
+
+func getSpotifySimilarArtistsInParallel(id, token string) {
+	fmt.Println("Searching Spotify for similar artists")
+	startTime := time.Now()
+	ch := make(chan spotify.SimilarArtistsResponse, len(artistsSearchResults))
+	semaphore := make(chan struct{}, spotifyThreads)
+	for i := range artistsSearchResults {
+		go func(i int) {
+			semaphore <- struct{}{}
+			defer func() { <-semaphore }()
+			spotify.SearchSpotifySimilarArtist(&artistsSearchResults[i], id, token, ch)
+		}(i)
+	}
+	// gather results
+	rawSimilarArtists := make([]spotify.SimilarArtistsResponse, 0)
+	for range artistsSearchResults {
+		result := <-ch
+		rawSimilarArtists = append(rawSimilarArtists, result)
+		fmt.Print(".")
+		numberOfArtistsProcessed++
+	}
+	fmt.Printf("Retrieved %d similar artists in %v\n", len(rawSimilarArtists), time.Since(startTime))
+	// seed the similar artists map with our owned artists
+	similarArtistsResults = make(map[string]types.MusicSimilarArtistResult)
+	for i := range artistsSearchResults {
+		// skip artists with no search results
+		if len(artistsSearchResults[i].MusicSearchResults) == 0 {
+			continue
+		}
+		similarArtistsResults[artistsSearchResults[i].MusicSearchResults[0].ID] = types.MusicSimilarArtistResult{
+			Name:            artistsSearchResults[i].MusicSearchResults[0].Name,
+			URL:             artistsSearchResults[i].MusicSearchResults[0].URL,
+			Owned:           true,
+			SimilarityCount: 0,
+		}
+	}
+	// iterate over searches
+	for i := range rawSimilarArtists {
+		// iterate over artists in each search
+		for j := range rawSimilarArtists[i].Artists {
+			artist, ok := similarArtistsResults[rawSimilarArtists[i].Artists[j].ID]
+			if !ok {
+				similarArtistsResults[rawSimilarArtists[i].Artists[j].ID] = types.MusicSimilarArtistResult{
+					Name:            rawSimilarArtists[i].Artists[j].Name,
+					URL:             fmt.Sprintf("https://open.spotify.com/artist/%s", rawSimilarArtists[i].Artists[j].ID),
+					Owned:           false,
+					SimilarityCount: 1,
+				}
+			} else {
+				// increment the similarity count
+				artist.SimilarityCount++
+				similarArtistsResults[rawSimilarArtists[i].Artists[j].ID] = artist
+			}
+		}
+	}
+	fmt.Printf("Processed %d similar artists in %v\n", len(rawSimilarArtists), time.Since(startTime))
+}
+
+func renderArtistAlbumsTable() (tableRows string) {
+	searchResults := filterMusicSearchResults(artistsSearchResults)
+	tableRows = `<thead><tr><th data-sort="string"><strong>Plex Artist</strong></th><th data-sort="int"><strong>Owned Albums</strong></th><th data-sort="int"><strong>Wanted Albums</strong></th><th><strong>Album</strong></th></tr></thead><tbody>` //nolint: lll
 	for i := range searchResults {
 		if len(searchResults[i].MusicSearchResults) > 0 {
-			tableRows += fmt.Sprintf(`<tr><td><a href=%q target="_blank">%s</a></td><td>%d</td><td><ul>`,
+			tableRows += fmt.Sprintf(`<tr><td><a href=%q target="_blank">%s</a></td><td>%d</td><td>%d</td><td><ul>`,
 				searchResults[i].MusicSearchResults[0].URL,
 				searchResults[i].PlexMusicArtist.Name,
+				searchResults[i].MusicSearchResults[0].OwnedAlbums,
 				len(searchResults[i].MusicSearchResults[0].Albums))
 			for j := range searchResults[i].MusicSearchResults[0].Albums {
 				tableRows += fmt.Sprintf(`<li><a href=%q target="_blank">%s</a> (%s)</li>`,
@@ -131,6 +250,22 @@ func renderArtistsTable(searchResults []types.SearchResults) (tableRows string)
 	return tableRows // Return the generated HTML for table rows
 }
 
+func renderSimilarArtistsTable() (tableRows string) {
+	tableRows = `<thead><tr><th data-sort="string"><strong>Plex Artist</strong></th><th data-sort="string"><strong>Owned</strong></th><th data-sort="int"><strong>Similarity Count</strong></th></tr></thead><tbody>` //nolint: lll
+	for i := range similarArtistsResults {
+		ownedString := "No"
+		if similarArtistsResults[i].Owned {
+			ownedString = "Yes"
+		}
+		tableRows += fmt.Sprintf(`<tr><td><a href=%q target="_blank">%s</a></td><td>%s</td><td>%d</td></tr>`,
+			similarArtistsResults[i].URL,
+			similarArtistsResults[i].Name,
+			ownedString,
+			similarArtistsResults[i].SimilarityCount)
+	}
+	return tableRows // Return the generated HTML for table rows
+}
+
 func filterMusicSearchResults(searchResults []types.SearchResults) []types.SearchResults {
 	searchResults = removeOwnedAlbums(searchResults)
 	searchResults = removeOlderSearchedAlbums(searchResults)
@@ -142,7 +277,7 @@ func removeOlderSearchedAlbums(searchResults []types.SearchResults) []types.Sear
 	filteredResults := make([]types.SearchResults, 0)
 	for i := range searchResults {
 		if len(searchResults[i].MusicSearchResults) > 0 {
-			filteredAlbums := make([]types.MusicSearchAlbumResult, 0)
+			filteredAlbums := make([]types.MusicAlbumSearchResult, 0)
 			for _, album := range searchResults[i].MusicSearchResults[0].Albums {
 				albumYear, _ := strconv.Atoi(album.Year)
 				if albumYear >= cutoffYear {
@@ -159,7 +294,9 @@ func removeOlderSearchedAlbums(searchResults []types.SearchResults) []types.Sear
 func removeOwnedAlbums(searchResults []types.SearchResults) []types.SearchResults {
 	for i := range searchResults {
 		if len(searchResults[i].MusicSearchResults) > 0 {
-			albumsToRemove := make([]types.MusicSearchAlbumResult, 0)
+			albumsToRemove := make([]types.MusicAlbumSearchResult, 0)
+			// set the number of owned albums
+			searchResults[i].MusicSearchResults[0].OwnedAlbums = len(searchResults[i].PlexMusicArtist.Albums)
 			// iterate over plex albums
 			for _, plexAlbum := range searchResults[i].PlexMusicArtist.Albums {
 				// iterate over search results
@@ -175,8 +312,8 @@ func removeOwnedAlbums(searchResults []types.SearchResults) []types.SearchResult
 	return searchResults
 }
 
-func cleanAlbums(original, toRemove []types.MusicSearchAlbumResult) []types.MusicSearchAlbumResult {
-	cleaned := make([]types.MusicSearchAlbumResult, 0)
+func cleanAlbums(original, toRemove []types.MusicAlbumSearchResult) []types.MusicAlbumSearchResult {
+	cleaned := make([]types.MusicAlbumSearchResult, 0)
 	for _, album := range original {
 		found := false
 		for _, remove := range toRemove {
diff --git a/web/music/music.html b/web/music/music.html
index 4f273b2..c1bd31b 100644
--- a/web/music/music.html
+++ b/web/music/music.html
@@ -47,7 +47,7 @@ <h1 class="container">Music</h1>
                 Missing albums (last 5 years)
             </label>
             <label for="New artists">
-                <input type="radio" id="newartists" name="lookuptype" value="newartists" disabled="true" />
+                <input type="radio" id="newartists" name="lookuptype" value="newartists" />
                 New artists
             </label>
         </fieldset>
diff --git a/web/music/music_test.go b/web/music/music_test.go
index f8de8a3..8187955 100644
--- a/web/music/music_test.go
+++ b/web/music/music_test.go
@@ -27,10 +27,10 @@ func Test_removeOwnedAlbums(t *testing.T) {
 							},
 						},
 					},
-					MusicSearchResults: []types.MusicSearchResult{
+					MusicSearchResults: []types.MusicArtistSearchResult{
 						{
 							Name: "Test Artist",
-							Albums: []types.MusicSearchAlbumResult{
+							Albums: []types.MusicAlbumSearchResult{
 								{
 									Title: "Test Album",
 									Year:  "2022",
@@ -55,10 +55,11 @@ func Test_removeOwnedAlbums(t *testing.T) {
 							},
 						},
 					},
-					MusicSearchResults: []types.MusicSearchResult{
+					MusicSearchResults: []types.MusicArtistSearchResult{
 						{
-							Name: "Test Artist",
-							Albums: []types.MusicSearchAlbumResult{
+							Name:        "Test Artist",
+							OwnedAlbums: 1,
+							Albums: []types.MusicAlbumSearchResult{
 								{
 									Title: "Test Album 2",
 									Year:  "2021",
@@ -87,10 +88,10 @@ func Test_removeOwnedAlbums(t *testing.T) {
 							},
 						},
 					},
-					MusicSearchResults: []types.MusicSearchResult{
+					MusicSearchResults: []types.MusicArtistSearchResult{
 						{
 							Name: "Another Artist",
-							Albums: []types.MusicSearchAlbumResult{
+							Albums: []types.MusicAlbumSearchResult{
 								{
 									Title: "Another Album",
 									Year:  "2021",
@@ -123,10 +124,11 @@ func Test_removeOwnedAlbums(t *testing.T) {
 							},
 						},
 					},
-					MusicSearchResults: []types.MusicSearchResult{
+					MusicSearchResults: []types.MusicArtistSearchResult{
 						{
-							Name: "Another Artist",
-							Albums: []types.MusicSearchAlbumResult{
+							Name:        "Another Artist",
+							OwnedAlbums: 2,
+							Albums: []types.MusicAlbumSearchResult{
 								{
 									Title: "Another Album 3",
 									Year:  "2023",
@@ -167,10 +169,10 @@ func Test_removeOlderSearchedAlbums(t *testing.T) {
 							},
 						},
 					},
-					MusicSearchResults: []types.MusicSearchResult{
+					MusicSearchResults: []types.MusicArtistSearchResult{
 						{
 							Name: "Test Artist",
-							Albums: []types.MusicSearchAlbumResult{
+							Albums: []types.MusicAlbumSearchResult{
 								{
 									Title: "Test Album 2",
 									Year:  "2016",
@@ -191,10 +193,10 @@ func Test_removeOlderSearchedAlbums(t *testing.T) {
 							},
 						},
 					},
-					MusicSearchResults: []types.MusicSearchResult{
+					MusicSearchResults: []types.MusicArtistSearchResult{
 						{
 							Name:   "Test Artist",
-							Albums: []types.MusicSearchAlbumResult{},
+							Albums: []types.MusicAlbumSearchResult{},
 						},
 					},
 				},
@@ -212,7 +214,7 @@ func Test_removeOlderSearchedAlbums(t *testing.T) {
 	}
 }
 func Test_cleanAlbums(t *testing.T) {
-	original := []types.MusicSearchAlbumResult{
+	original := []types.MusicAlbumSearchResult{
 		{
 			Title: "Album 1",
 			Year:  "2022",
@@ -226,7 +228,7 @@ func Test_cleanAlbums(t *testing.T) {
 			Year:  "2020",
 		},
 	}
-	toRemove := []types.MusicSearchAlbumResult{
+	toRemove := []types.MusicAlbumSearchResult{
 		{
 			Title: "Album 2",
 			Year:  "2021",
@@ -236,7 +238,7 @@ func Test_cleanAlbums(t *testing.T) {
 			Year:  "2020",
 		},
 	}
-	want := []types.MusicSearchAlbumResult{
+	want := []types.MusicAlbumSearchResult{
 		{
 			Title: "Album 1",
 			Year:  "2022",
diff --git a/web/server.go b/web/server.go
index 82892d2..ee7c14e 100644
--- a/web/server.go
+++ b/web/server.go
@@ -78,6 +78,8 @@ func settingsSaveHandler(w http.ResponseWriter, r *http.Request) {
 	config.PlexMovieLibraryID = r.FormValue("plexMovieLibraryID")
 	config.PlexTVLibraryID = r.FormValue("plexTVLibraryID")
 	config.PlexMusicLibraryID = r.FormValue("plexMusicLibraryID")
+	config.SpotifyClientID = r.FormValue("spotifyClientID")
+	config.SpotifyClientSecret = r.FormValue("spotifyClientSecret")
 	fmt.Fprint(w, `<h2>Saved!</h2><a href="/">Back</a>`)
 	fmt.Printf("Saved Settings\nold\n%+v\nnew\n%+v\n", oldConfig, config)
 }
diff --git a/web/settings/settings.go b/web/settings/settings.go
index 3826578..b960c36 100644
--- a/web/settings/settings.go
+++ b/web/settings/settings.go
@@ -76,10 +76,6 @@ func renderLibraries(libraries []types.PlexLibrary) string {
 	for _, library := range libraries {
 		html += fmt.Sprintf(`<tr><td>%s</td><td>%s</td><td>%s</td></tr>`, library.Title, library.Type, library.ID)
 	}
-	html += `</tbody></table>
-<input type="text" placeholder="Plex Movie Library Section ID" name="plexMovieLibraryID"id="plexMovieLibraryID">
-<input type="text" placeholder="Plex TV Series Library Section ID" name="plexTVLibraryID"id="plexTVLibraryID">
-<input type="text" placeholder="Plex Music Library Section ID" name="plexMusicLibraryID"id="plexMusicLibraryID">
-<button hx-post="/settings/save" hx-include="#plexMovieLibraryID,#plexTVLibraryID,#plexMusicLibraryID,#plexIP,#plexToken" hx-swap="outerHTML">Save</button>` //nolint: lll
+	html += "</tbody></table>"
 	return html
 }
diff --git a/web/settings/settings.html b/web/settings/settings.html
index b9a7144..47df906 100644
--- a/web/settings/settings.html
+++ b/web/settings/settings.html
@@ -9,8 +9,9 @@
 </head>
 
 <body>
-    <h1 class="container">Plex-lookup Settings</h1>
-    <form hx-post="/settings/plexlibraries" class="container" hx-target="#table" hx-boost="true">
+    <h1 class="container">Settings</h1>
+    <h2 class="container">Plex</h2>
+    <div class="container">
         <p class="container">Enter the <em
                 data-tooltip="Find your Plex server IP by going to your server then go to settings, then remote-access. It is the private IP address."><a
                     href="https://plex.tv/web" target="_blank">Plex
@@ -22,9 +23,31 @@ <h1 class="container">Plex-lookup Settings</h1>
         </p>
         <input type="text" placeholder="Plex Server IP" name="plexIP" id="plexIP">
         <input type="text" placeholder="Plex X-Plex-Token" name="plexToken" id="plexToken">
-        <button type="lookupPlex">Lookup Plex libraries</button>
-    </form>
-    <div id="table" class="container"></div>
+        <button type="lookupPlex" hx-post="/settings/plexlibraries" class="container" hx-target="#table"
+            hx-include="#plexIP, #plexToken" hx-boost="true">Lookup Plex libraries</button>
+        <div id="table" class="container"></div>
+        <input type="text" placeholder="Plex Movie Library Section ID" name="plexMovieLibraryID"
+            id="plexMovieLibraryID">
+        <input type="text" placeholder="Plex TV Series Library Section ID" name="plexTVLibraryID" id="plexTVLibraryID">
+        <input type="text" placeholder="Plex Music Library Section ID" name="plexMusicLibraryID"
+            id="plexMusicLibraryID">
+    </div>
+    <h2 class="container">Spotify</h2>
+    <p class="container">Enter your Spotify client ID and secret to get started. You will need to follow the Spotify
+        documentation to get these. <a href="https://developer.spotify.com/documentation/web-api/concepts/apps"
+            target="_blank">Create
+            an app on the Spotify developer dashboard</a>
+        then get the client ID and secret.
+    </p>
+    <div class="container">
+        <input type="text" placeholder="Spotify client ID" name="spotifyClientID" id="spotifyClientID">
+        <input type="text" placeholder="Spotify Secret" name="spotifyClientSecret" id="spotifyClientSecret">
+    </div>
+    <div class="container">
+        <button hx-post="/settings/save"
+            hx-include="#plexMovieLibraryID, #plexTVLibraryID, #plexMusicLibraryID, #plexIP, #plexToken, #spotifyClientID, #spotifyClientSecret"
+            hx-swap="outerHTML">Save</button>
+    </div>
 </body>
 
 </html>
\ No newline at end of file