diff --git a/src/main.ts b/src/main.ts
index b644ff3..6d7df87 100644
--- a/src/main.ts
+++ b/src/main.ts
@@ -50,6 +50,7 @@ watch(
       return Promise.all([
         useFavouriteStore().load(),
         usePlaylistStore().load(),
+        playerStore.dispatch('player/loadQueue'),
       ])
     }
   })
diff --git a/src/player/Player.vue b/src/player/Player.vue
index b07679f..2e38034 100644
--- a/src/player/Player.vue
+++ b/src/player/Player.vue
@@ -1,5 +1,5 @@
 <template>
-  <div :class="{'visible': visible}" class="player elevated d-flex">
+  <div :class="{'visible': track}" class="player elevated d-flex">
     <div class="flex-fill">
       <ProgressBar v-if="track" style="margin-bottom: -5px; margin-top: -9px" />
 
@@ -145,9 +145,6 @@
       }
     },
     computed: {
-      visible() {
-        return this.$store.state.player.queue.length > 0
-      },
       isPlaying() {
         return this.$store.state.player.isPlaying
       },
diff --git a/src/player/Queue.vue b/src/player/Queue.vue
index 315e96f..fc306dc 100644
--- a/src/player/Queue.vue
+++ b/src/player/Queue.vue
@@ -13,38 +13,40 @@
         </b-button>
       </div>
     </div>
-    <BaseTable v-if="tracks.length > 0">
-      <BaseTableHead>
-        <th class="text-left d-none d-lg-table-cell">
-          Artist
-        </th>
-        <th class="text-left d-none d-md-table-cell">
-          Album
-        </th>
-        <th class="text-right d-none d-md-table-cell">
-          Duration
-        </th>
-      </BaseTableHead>
-      <tbody>
-        <tr v-for="(item, index) in tracks" :key="index"
-            :class="{'active': index === queueIndex}"
-            :draggable="true" @dragstart="dragstart(item.id, $event)"
-            @click="play(index)">
-          <CellTrackNumber :active="index === queueIndex && isPlaying" :value="item.track" />
-          <CellTitle :track="item" />
-          <CellArtist :track="item" />
-          <CellAlbum :track="item" />
-          <CellDuration :track="item" />
-          <CellActions :track="item">
-            <b-dropdown-divider />
-            <ContextMenuItem icon="x" variant="danger" @click="remove(index)">
-              Remove
-            </ContextMenuItem>
-          </CellActions>
-        </tr>
-      </tbody>
-    </BaseTable>
-    <EmptyIndicator v-else />
+    <ContentLoader v-slot :loading="loading">
+      <BaseTable v-if="tracks.length > 0">
+        <BaseTableHead>
+          <th class="text-left d-none d-lg-table-cell">
+            Artist
+          </th>
+          <th class="text-left d-none d-md-table-cell">
+            Album
+          </th>
+          <th class="text-right d-none d-md-table-cell">
+            Duration
+          </th>
+        </BaseTableHead>
+        <tbody>
+          <tr v-for="(item, index) in tracks" :key="index"
+              :class="{'active': index === queueIndex}"
+              :draggable="true" @dragstart="dragstart(item.id, $event)"
+              @click="play(index)">
+            <CellTrackNumber :active="index === queueIndex && isPlaying" :value="item.track" />
+            <CellTitle :track="item" />
+            <CellArtist :track="item" />
+            <CellAlbum :track="item" />
+            <CellDuration :track="item" />
+            <CellActions :track="item">
+              <b-dropdown-divider />
+              <ContextMenuItem icon="x" variant="danger" @click="remove(index)">
+                Remove
+              </ContextMenuItem>
+            </CellActions>
+          </tr>
+        </tbody>
+      </BaseTable>
+      <EmptyIndicator v-else />
+    </ContentLoader>
   </div>
 </template>
 <script lang="ts">
@@ -70,6 +72,9 @@
       BaseTable,
     },
     computed: {
+      loading() {
+        return this.$store.state.player.queue === null
+      },
       isPlaying() {
         return this.$store.getters['player/isPlaying']
       },
diff --git a/src/player/store.ts b/src/player/store.ts
index 99c4e54..45ab377 100644
--- a/src/player/store.ts
+++ b/src/player/store.ts
@@ -1,19 +1,21 @@
 import Vuex, { Store, Module } from 'vuex'
 import { shuffle, shuffled, trackListEquals, formatArtists } from '@/shared/utils'
-import { API } from '@/shared/api'
+import { API, Track } from '@/shared/api'
 import { AudioController } from '@/player/audio'
 import { useMainStore } from '@/shared/store'
+import { ref } from 'vue'
 
 localStorage.removeItem('player.mute')
-const storedQueue = JSON.parse(localStorage.getItem('queue') || '[]')
-const storedQueueIndex = parseInt(localStorage.getItem('queueIndex') || '-1')
+localStorage.removeItem('queue')
+localStorage.removeItem('queueIndex')
+
 const storedVolume = parseFloat(localStorage.getItem('player.volume') || '1.0')
 const storedPodcastPlaybackRate = parseFloat(localStorage.getItem('player.podcastPlaybackRate') || '1.0')
 const mediaSession: MediaSession | undefined = navigator.mediaSession
 const audio = new AudioController()
 
 interface State {
-  queue: any[];
+  queue: null | Track[];
   queueIndex: number;
   scrobbled: boolean;
   isPlaying: boolean;
@@ -26,248 +28,248 @@ interface State {
   podcastPlaybackRate: number;
 }
 
-function persistQueue(state: State) {
-  localStorage.setItem('queue', JSON.stringify(state.queue))
-  localStorage.setItem('queueIndex', state.queueIndex.toString())
-}
-
-export const playerModule: Module<State, any> = {
-  namespaced: true,
-  state: {
-    queue: storedQueue,
-    queueIndex: storedQueueIndex,
-    scrobbled: false,
-    isPlaying: false,
-    duration: 0,
-    currentTime: 0,
-    streamTitle: null,
-    repeat: localStorage.getItem('player.repeat') !== 'false',
-    shuffle: localStorage.getItem('player.shuffle') === 'true',
-    volume: storedVolume,
-    podcastPlaybackRate: storedPodcastPlaybackRate,
-  },
-
-  mutations: {
-    setPlaying(state) {
-      state.isPlaying = true
-      if (mediaSession) {
-        mediaSession.playbackState = 'playing'
-      }
-    },
-    setPaused(state) {
-      state.isPlaying = false
-      if (mediaSession) {
-        mediaSession.playbackState = 'paused'
-      }
-    },
-    setRepeat(state, enable) {
-      state.repeat = enable
-      localStorage.setItem('player.repeat', enable)
-    },
-    setShuffle(state, enable) {
-      state.shuffle = enable
-      localStorage.setItem('player.shuffle', enable)
+function createPlayerModule(api: API): Module<State, any> {
+  return {
+    namespaced: true,
+    state: {
+      queue: null,
+      queueIndex: -1,
+      scrobbled: false,
+      isPlaying: false,
+      duration: 0,
+      currentTime: 0,
+      streamTitle: null,
+      repeat: localStorage.getItem('player.repeat') !== 'false',
+      shuffle: localStorage.getItem('player.shuffle') === 'true',
+      volume: storedVolume,
+      podcastPlaybackRate: storedPodcastPlaybackRate,
     },
-    setQueue(state, queue) {
-      state.queue = queue
-      state.queueIndex = -1
-      persistQueue(state)
-    },
-    setQueueIndex(state, index) {
-      if (state.queue.length === 0) {
-        return
-      }
-      index = Math.max(0, index)
-      index = index < state.queue.length ? index : 0
-      state.queueIndex = index
-      persistQueue(state)
-      state.scrobbled = false
-      const track = state.queue[index]
-      state.duration = track.duration
-      const next = (index + 1) % state.queue.length
-      audio.setBuffer(state.queue[next].url)
-      if (mediaSession) {
-        mediaSession.metadata = new MediaMetadata({
-          title: track.title,
-          artist: formatArtists(track.artists),
-          album: track.album,
-          artwork: track.image ? [{ src: track.image, sizes: '300x300' }] : undefined,
-        })
-      }
-    },
-    addToQueue(state, tracks) {
-      state.queue.push(...tracks)
-      persistQueue(state)
-    },
-    removeFromQueue(state, index) {
-      state.queue.splice(index, 1)
-      if (index < state.queueIndex) {
-        state.queueIndex--
-      }
-      persistQueue(state)
-    },
-    clearQueue(state) {
-      if (state.queueIndex >= 0) {
-        state.queue = [state.queue[state.queueIndex]]
-        state.queueIndex = 0
-        persistQueue(state)
-      }
-    },
-    shuffleQueue(state) {
-      if (state.queue.length > 0) {
-        state.queue = shuffled(state.queue, state.queueIndex)
-        state.queueIndex = 0
-        persistQueue(state)
-      }
-    },
-    setNextInQueue(state, tracks) {
-      state.queue.splice(state.queueIndex + 1, 0, ...tracks)
-      persistQueue(state)
-    },
-    setCurrentTime(state, value: any) {
-      state.currentTime = value
-    },
-    setDuration(state, value: any) {
-      if (isFinite(value)) {
-        state.duration = value
-      }
-    },
-    setStreamTitle(state, value: string | null) {
-      state.streamTitle = value
-      if (value && mediaSession?.metadata) {
-        mediaSession.metadata.title = value
-      }
-    },
-    setScrobbled(state) {
-      state.scrobbled = true
-    },
-    setVolume(state, value: number) {
-      state.volume = value
-      localStorage.setItem('player.volume', String(value))
-    },
-    setPodcastPlaybackRate(state, value) {
-      state.podcastPlaybackRate = value
-      localStorage.setItem('player.podcastPlaybackRate', String(value))
-    }
-  },
 
-  actions: {
-    async playNow({ commit, dispatch }, { tracks }) {
-      commit('setShuffle', false)
-      dispatch('playTrackList', { tracks, index: 0 })
-    },
-    async shuffleNow({ commit, dispatch }, { tracks }) {
-      commit('setShuffle', true)
-      dispatch('playTrackList', { tracks })
-    },
-    async playTrackListIndex({ commit, getters }, { index }) {
-      commit('setQueueIndex', index)
-      commit('setPlaying')
-      await audio.changeTrack({ ...getters.track, playbackRate: getters.playbackRate })
+    mutations: {
+      setPlaying(state) {
+        state.isPlaying = true
+        if (mediaSession) {
+          mediaSession.playbackState = 'playing'
+        }
+      },
+      setPaused(state) {
+        state.isPlaying = false
+        if (mediaSession) {
+          mediaSession.playbackState = 'paused'
+        }
+      },
+      setRepeat(state, enable) {
+        state.repeat = enable
+        localStorage.setItem('player.repeat', enable)
+      },
+      setShuffle(state, enable) {
+        state.shuffle = enable
+        localStorage.setItem('player.shuffle', enable)
+      },
+      setQueue(state, queue) {
+        state.queue = queue
+        state.queueIndex = -1
+      },
+      setQueueIndex(state, index) {
+        if (!state.queue || state.queue.length === 0) {
+          return
+        }
+        index = Math.max(0, index)
+        index = index < state.queue.length ? index : 0
+        state.queueIndex = index
+        state.scrobbled = false
+        const track = state.queue[index]
+        state.duration = track.duration
+        const next = (index + 1) % state.queue.length
+        audio.setBuffer(state.queue[next].url!)
+        if (mediaSession) {
+          mediaSession.metadata = new MediaMetadata({
+            title: track.title,
+            artist: formatArtists(track.artists),
+            album: track.album,
+            artwork: track.image ? [{ src: track.image, sizes: '300x300' }] : undefined,
+          })
+        }
+      },
+      addToQueue(state, tracks) {
+        state.queue?.push(...tracks)
+      },
+      removeFromQueue(state, index) {
+        state.queue?.splice(index, 1)
+        if (index < state.queueIndex) {
+          state.queueIndex--
+        }
+      },
+      clearQueue(state) {
+        if (state.queue && state.queueIndex >= 0) {
+          state.queue = [state.queue[state.queueIndex]]
+          state.queueIndex = 0
+        }
+      },
+      shuffleQueue(state) {
+        if (state.queue && state.queue.length > 0) {
+          state.queue = shuffled(state.queue, state.queueIndex)
+          state.queueIndex = 0
+        }
+      },
+      setNextInQueue(state, tracks) {
+        state.queue?.splice(state.queueIndex + 1, 0, ...tracks)
+      },
+      setCurrentTime(state, value: any) {
+        state.currentTime = value
+      },
+      setDuration(state, value: any) {
+        if (isFinite(value)) {
+          state.duration = value
+        }
+      },
+      setStreamTitle(state, value: string | null) {
+        state.streamTitle = value
+        if (value && mediaSession?.metadata) {
+          mediaSession.metadata.title = value
+        }
+      },
+      setScrobbled(state) {
+        state.scrobbled = true
+      },
+      setVolume(state, value: number) {
+        state.volume = value
+        localStorage.setItem('player.volume', String(value))
+      },
+      setPodcastPlaybackRate(state, value) {
+        state.podcastPlaybackRate = value
+        localStorage.setItem('player.podcastPlaybackRate', String(value))
+      },
     },
-    async playTrackList({ commit, state, getters }, { tracks, index }) {
-      if (index == null) {
-        index = state.shuffle ? Math.floor(Math.random() * tracks.length) : 0
-      }
-      if (state.shuffle) {
-        tracks = [...tracks]
-        shuffle(tracks, index)
-        index = 0
-      }
-      if (!trackListEquals(state.queue, tracks)) {
+
+    actions: {
+      async playNow({ commit, dispatch }, { tracks }) {
+        commit('setShuffle', false)
+        dispatch('playTrackList', { tracks, index: 0 })
+      },
+      async shuffleNow({ commit, dispatch }, { tracks }) {
+        commit('setShuffle', true)
+        dispatch('playTrackList', { tracks })
+      },
+      async playTrackListIndex({ commit, getters }, { index }) {
+        commit('setQueueIndex', index)
+        commit('setPlaying')
+        await audio.changeTrack({ ...getters.track, playbackRate: getters.playbackRate })
+      },
+      async playTrackList({ commit, state, getters }, { tracks, index }) {
+        if (index == null) {
+          index = state.shuffle ? Math.floor(Math.random() * tracks.length) : 0
+        }
+        if (state.shuffle) {
+          tracks = [...tracks]
+          shuffle(tracks, index)
+          index = 0
+        }
+        if (!trackListEquals(state.queue || [], tracks)) {
+          commit('setQueue', tracks)
+        }
+        commit('setQueueIndex', index)
+        commit('setPlaying')
+        await audio.changeTrack({ ...getters.track, playbackRate: getters.playbackRate })
+      },
+      async resume({ commit }) {
+        commit('setPlaying')
+        await audio.resume()
+      },
+      async pause({ commit }) {
+        audio.pause()
+        commit('setPaused')
+      },
+      async playPause({ state, dispatch }) {
+        return state.isPlaying ? dispatch('pause') : dispatch('resume')
+      },
+      async next({ commit, state, getters }) {
+        commit('setQueueIndex', state.queueIndex + 1)
+        commit('setPlaying')
+        await audio.changeTrack({ ...getters.track, playbackRate: getters.playbackRate })
+      },
+      async previous({ commit, state, getters }) {
+        commit('setQueueIndex', audio.currentTime() > 3 ? state.queueIndex : state.queueIndex - 1)
+        commit('setPlaying')
+        await audio.changeTrack(getters.track)
+      },
+      seek({ state }, value) {
+        if (isFinite(state.duration)) {
+          audio.seek(state.duration * value)
+        }
+      },
+
+      async loadQueue({ commit, getters }) {
+        const { tracks, currentTrack, currentTrackPosition } = await api.getPlayQueue()
         commit('setQueue', tracks)
-      }
-      commit('setQueueIndex', index)
-      commit('setPlaying')
-      await audio.changeTrack({ ...getters.track, playbackRate: getters.playbackRate })
-    },
-    async resume({ commit }) {
-      commit('setPlaying')
-      await audio.resume()
-    },
-    async pause({ commit }) {
-      audio.pause()
-      commit('setPaused')
-    },
-    async playPause({ state, dispatch }) {
-      return state.isPlaying ? dispatch('pause') : dispatch('resume')
-    },
-    async next({ commit, state, getters }) {
-      commit('setQueueIndex', state.queueIndex + 1)
-      commit('setPlaying')
-      await audio.changeTrack({ ...getters.track, playbackRate: getters.playbackRate })
-    },
-    async previous({ commit, state, getters }) {
-      commit('setQueueIndex', audio.currentTime() > 3 ? state.queueIndex : state.queueIndex - 1)
-      commit('setPlaying')
-      await audio.changeTrack(getters.track)
-    },
-    seek({ state }, value) {
-      if (isFinite(state.duration)) {
-        audio.seek(state.duration * value)
-      }
-    },
-    async resetQueue({ commit, getters }) {
-      commit('setQueueIndex', 0)
-      commit('setPaused')
-      await audio.changeTrack({ ...getters.track, paused: true, playbackRate: getters.playbackRate })
-    },
-    toggleRepeat({ commit, state }) {
-      commit('setRepeat', !state.repeat)
-    },
-    toggleShuffle({ commit, state }) {
-      commit('setShuffle', !state.shuffle)
-    },
-    setShuffle({ commit }, enable: boolean) {
-      commit('setShuffle', enable)
-    },
-    addToQueue({ state, commit }, tracks) {
-      commit('addToQueue', state.shuffle ? shuffled(tracks) : tracks)
-    },
-    setNextInQueue({ state, commit }, tracks) {
-      commit('setNextInQueue', state.shuffle ? shuffled(tracks) : tracks)
-    },
-    setVolume({ commit }, value) {
-      audio.setVolume(value)
-      commit('setVolume', value)
-    },
-    setPlaybackRate({ commit, getters }, value) {
-      commit('setPodcastPlaybackRate', value)
-      if (getters.track?.isPodcast) {
-        audio.setPlaybackRate(value)
-      }
-    },
-  },
+        commit('setQueueIndex', currentTrack)
+        commit('setPaused')
+        await audio.changeTrack({ ...getters.track, paused: true, playbackRate: getters.playbackRate })
+        await audio.seek(currentTrackPosition)
+      },
 
-  getters: {
-    track(state) {
-      if (state.queueIndex !== -1) {
-        return state.queue[state.queueIndex]
-      }
-      return null
-    },
-    trackId(state, getters): number {
-      return getters.track ? getters.track.id : -1
-    },
-    isPlaying(state): boolean {
-      return state.isPlaying
-    },
-    progress(state): number {
-      if (state.currentTime > -1 && state.duration > 0) {
-        return state.currentTime / state.duration
-      }
-      return 0
-    },
-    hasNext(state) {
-      return state.queueIndex < state.queue.length - 1
-    },
-    hasPrevious(state) {
-      return state.queueIndex > 0
+      async resetQueue({ commit, getters }) {
+        commit('setQueueIndex', 0)
+        commit('setPaused')
+        await audio.changeTrack({ ...getters.track, paused: true, playbackRate: getters.playbackRate })
+      },
+      toggleRepeat({ commit, state }) {
+        commit('setRepeat', !state.repeat)
+      },
+      toggleShuffle({ commit, state }) {
+        commit('setShuffle', !state.shuffle)
+      },
+      setShuffle({ commit }, enable: boolean) {
+        commit('setShuffle', enable)
+      },
+      addToQueue({ state, commit }, tracks) {
+        commit('addToQueue', state.shuffle ? shuffled(tracks) : tracks)
+      },
+      setNextInQueue({ state, commit }, tracks) {
+        commit('setNextInQueue', state.shuffle ? shuffled(tracks) : tracks)
+      },
+      setVolume({ commit }, value) {
+        audio.setVolume(value)
+        commit('setVolume', value)
+      },
+      setPlaybackRate({ commit, getters }, value) {
+        commit('setPodcastPlaybackRate', value)
+        if (getters.track?.isPodcast) {
+          audio.setPlaybackRate(value)
+        }
+      },
     },
-    playbackRate(state, getters): number {
-      return getters.track?.isPodcast ? state.podcastPlaybackRate : 1.0
+
+    getters: {
+      track(state) {
+        if (state.queue && state.queueIndex !== -1) {
+          return state.queue[state.queueIndex]
+        }
+        return null
+      },
+      trackId(state, getters): number {
+        return getters.track ? getters.track.id : -1
+      },
+      isPlaying(state): boolean {
+        return state.isPlaying
+      },
+      progress(state): number {
+        if (state.currentTime > -1 && state.duration > 0) {
+          return state.currentTime / state.duration
+        }
+        return 0
+      },
+      hasNext(state) {
+        return state.queue && state.queueIndex < state.queue.length - 1
+      },
+      hasPrevious(state) {
+        return state.queueIndex > 0
+      },
+      playbackRate(state, getters): number {
+        return getters.track?.isPodcast ? state.podcastPlaybackRate : 1.0
+      },
     },
-  },
+  }
 }
 
 export function createPlayerStore(mainStore: ReturnType<typeof useMainStore>, api: API) {
@@ -276,7 +278,7 @@ export function createPlayerStore(mainStore: ReturnType<typeof useMainStore>, ap
     modules: {
       player: {
         namespaced: true,
-        ...playerModule
+        ...createPlayerModule(api)
       },
     }
   })
@@ -382,5 +384,34 @@ function setupAudio(store: Store<any>, mainStore: ReturnType<typeof useMainStore
           }
         }
       })
+
+    // Save play queue
+    const maxDuration = 10_000
+    const lastSaved = ref(Date.now())
+
+    store.watch(
+      (state) => [
+        state.player.queue,
+        state.player.queueIndex,
+      ],
+      (_: any, [oldQueue]) => {
+        if (oldQueue !== null) {
+          lastSaved.value = Date.now()
+          const { queue, queueIndex, currentTime } = store.state.player
+          return api.savePlayQueue(queue, queueIndex, currentTime)
+        }
+      })
+
+    store.watch(
+      (state) => [state.player.currentTime],
+      () => {
+        const now = Date.now()
+        const duration = now - lastSaved.value
+        if (duration >= maxDuration) {
+          lastSaved.value = now
+          const { queue, queueIndex, currentTime } = store.state.player
+          return api.savePlayQueue(queue, queueIndex, currentTime)
+        }
+      })
   }
 }
diff --git a/src/shared/api.ts b/src/shared/api.ts
index f9d5d40..82e0d5c 100644
--- a/src/shared/api.ts
+++ b/src/shared/api.ts
@@ -99,8 +99,23 @@ export interface Playlist {
   tracks?: Track[]
 }
 
+export interface PlayQueue {
+  tracks: Track[]
+  currentTrack: number
+  currentTrackPosition: number
+}
+
 export class UnsupportedOperationError extends Error { }
 
+export class SubsonicError extends Error {
+  readonly code: string | null
+  constructor(message: string, code: string | null) {
+    super(message)
+    this.name = 'SubsonicError'
+    this.code = code
+  }
+}
+
 export class API {
   private readonly fetch: (path: string, params?: any) => Promise<any>
   private readonly clientName = window.origin || 'web'
@@ -143,8 +158,9 @@ export class API {
           if (subsonicResponse.status === 'ok') {
             return subsonicResponse
           }
+          const code = subsonicResponse.error?.code
           const message = subsonicResponse.error?.message || subsonicResponse.status
-          throw new Error(message)
+          throw new SubsonicError(message, code)
         })
     }
   }
@@ -294,6 +310,35 @@ export class API {
     await this.fetch('rest/updatePlaylist', params)
   }
 
+  async getPlayQueue(): Promise<PlayQueue> {
+    const response = await this.fetch('rest/getPlayQueue')
+    const tracks = (response.playQueue?.entry || []).map(this.normalizeTrack, this) as Track[]
+    const currentTrackId = response.playQueue?.current?.toString()
+    const currentTrack = tracks.findIndex(track => track.id === currentTrackId) ?? 0
+    return {
+      tracks,
+      currentTrack,
+      currentTrackPosition: (response.playQueue?.position || 0) / 1000,
+    }
+  }
+
+  async savePlayQueue(tracks: Track[], current: number, currentTime: number) {
+    const params = {
+      id: tracks.map(track => track.id),
+      current: tracks[current]?.id,
+      position: Math.round(currentTime * 1000),
+    }
+    try {
+      await this.fetch('rest/savePlayQueue', params)
+    } catch (err: any) {
+      // ignore missing required parameter error
+      if (err.code === 10) {
+        return
+      }
+      throw err
+    }
+  }
+
   async getRandomSongs(): Promise<Track[]> {
     const params = {
       size: 200,
diff --git a/src/shared/utils.ts b/src/shared/utils.ts
index 71db1b9..16ce04b 100644
--- a/src/shared/utils.ts
+++ b/src/shared/utils.ts
@@ -43,7 +43,7 @@ export function trackListEquals(a: Track[], b: Track[]): boolean {
   return true
 }
 
-export function formatArtists(artists: Artist[]): string {
+export function formatArtists(artists: { name: string }[]): string {
   return artists.map(ar => ar.name).join(', ')
 }