diff --git a/frontend/src/components/VContentReport/VContentReportForm.vue b/frontend/src/components/VContentReport/VContentReportForm.vue
index 5c698d2fd30..1c5fbfc5113 100644
--- a/frontend/src/components/VContentReport/VContentReportForm.vue
+++ b/frontend/src/components/VContentReport/VContentReportForm.vue
@@ -126,9 +126,9 @@
 <script setup lang="ts">
 import { useNuxtApp, useRuntimeConfig } from "#imports"
 
-import { computed, ref } from "vue"
+import { ofetch } from "ofetch"
 
-import axios from "axios"
+import { computed, ref } from "vue"
 
 import {
   reasons,
@@ -138,7 +138,7 @@ import {
   FAILED,
   WIP,
   DMCA_FORM_URL,
-  ReportReason,
+  type ReportReason,
 } from "~/constants/content-report"
 
 import type { AudioDetail, ImageDetail } from "~/types/media"
@@ -208,13 +208,16 @@ const handleSubmit = async (event: Event) => {
     } = useRuntimeConfig()
 
     // Not proxied through the Nuxt `/api/` because it is a POST request
-    await axios.post(
+    await ofetch(
       `${apiUrl}v1/${mediaSlug(mediaType)}/${props.media.id}/report/`,
       {
-        mediaType,
-        reason,
-        identifier: props.media.id,
-        description: description.value,
+        method: "POST",
+        body: {
+          mediaType,
+          reason,
+          identifier: props.media.id,
+          description: description.value,
+        },
       }
     )
 
diff --git a/frontend/src/constants/errors.ts b/frontend/src/constants/errors.ts
index f038fb14e7a..daf8b938c68 100644
--- a/frontend/src/constants/errors.ts
+++ b/frontend/src/constants/errors.ts
@@ -16,26 +16,19 @@ export const customErrorCodes = [
   ERR_UNKNOWN,
 ] as const
 
-/**
- * The error codes Axios uses.
- * @see https://github.com/axios/axios/blob/9588fcdec8aca45c3ba2f7968988a5d03f23168c/lib/core/AxiosError.js#L57C2-L71
- */
-const axiosErrorCodes = [
-  "ERR_BAD_OPTION_VALUE",
-  "ERR_BAD_OPTION",
-  "ECONNABORTED",
-  "ETIMEDOUT",
-  "ERR_NETWORK",
-  "ERR_FR_TOO_MANY_REDIRECTS",
-  "ERR_DEPRECATED",
-  "ERR_BAD_RESPONSE",
-  "ERR_BAD_REQUEST",
-  "ERR_CANCELED",
-  "ERR_NOT_SUPPORT",
-  "ERR_INVALID_URL",
-] as const
+export const ofetchErrorCodes = [
+  "Too many results",
+  "Request Timeout",
+  "Conflict",
+  "Too Early",
+  "Too Many Requests",
+  "Internal Server Error",
+  "Bad Gateway",
+  "Service Unavailable",
+  "Gateway Timeout",
+]
 
-export const errorCodes = [...customErrorCodes, ...axiosErrorCodes] as const
+export const errorCodes = [...customErrorCodes, ...ofetchErrorCodes] as const
 
 export const clientSideErrorCodes: readonly ErrorCode[] = [
   ECONNABORTED,
diff --git a/frontend/src/pages/image/[id]/index.vue b/frontend/src/pages/image/[id]/index.vue
index f580b097024..d910d655e0a 100644
--- a/frontend/src/pages/image/[id]/index.vue
+++ b/frontend/src/pages/image/[id]/index.vue
@@ -84,7 +84,7 @@ import {
 
 import { computed, onMounted, ref, watch } from "vue"
 
-import axios from "axios"
+import { ofetch } from "ofetch"
 
 import { IMAGE } from "~/constants/media"
 import { skipToContentTargetId } from "~/constants/window"
@@ -181,8 +181,8 @@ const sketchFabUid = computed(() => {
 })
 
 const fetchFiletype = async (url: string) => {
-  const response = await axios.head(url)
-  const contentType = response.headers["content-type"]
+  const response = await ofetch.raw(url, { method: "HEAD" })
+  const contentType = response.headers.get("content-type")
   if (contentType?.includes("image")) {
     return contentType.split("/")[1]
   }
diff --git a/frontend/src/stores/media/index.ts b/frontend/src/stores/media/index.ts
index bb9dbad975b..304477955cb 100644
--- a/frontend/src/stores/media/index.ts
+++ b/frontend/src/stores/media/index.ts
@@ -1,9 +1,8 @@
-import { decodeMediaData, useRequestEvent } from "#imports"
+import { createError, decodeMediaData } from "#imports"
 
+import { ofetch } from "ofetch"
 import { defineStore } from "pinia"
 
-import axios from "axios"
-
 import { warn } from "~/utils/console"
 import { hash, rand as prng } from "~/utils/prng"
 import { isRetriable, parseFetchingError } from "~/utils/errors"
@@ -20,9 +19,9 @@ import {
   AUDIO,
   IMAGE,
   isAdditionalSearchType,
-  SupportedMediaType,
   supportedMediaTypes,
-  SupportedSearchType,
+  type SupportedMediaType,
+  type SupportedSearchType,
 } from "~/constants/media"
 import { NO_RESULT } from "~/constants/errors"
 import { isSearchTypeSupported, useSearchStore } from "~/stores/search"
@@ -31,6 +30,10 @@ import { deepFreeze } from "~/utils/deep-freeze"
 import { mediaSlug, DEFAULT_REQUEST_TIMEOUT } from "~/utils/query-utils"
 
 import type { PaginatedApiMediaResult } from "~/types/api"
+import type {
+  PaginatedCollectionQuery,
+  PaginatedSearchQuery,
+} from "~/types/search"
 
 export type MediaStoreResult = {
   count: number
@@ -459,34 +462,18 @@ export const useMediaStore = defineStore("media", {
     }) {
       this._updateFetchState(mediaType, "start")
 
-      let page = this.results[mediaType].page + 1
+      const page = this.results[mediaType].page + 1
       const { pathSlug, queryParams } = this.getSearchUrlParts(
         mediaType,
         page,
         shouldPersistMedia
       )
-      const { url, baseURL } = this.getFetchUrl(mediaType, pathSlug)
+      const url = `/api/${mediaSlug(mediaType)}/${pathSlug}`
 
       try {
-        const res = await axios.get<PaginatedApiMediaResult>(url, {
-          baseURL,
-          params: queryParams,
-          timeout: DEFAULT_REQUEST_TIMEOUT,
-        })
-
-        const data = this.decodeData(res.data, mediaType)
-
+        const data = await this.fetchAndDecode(mediaType, url, queryParams)
+        this._updateFetchState(mediaType, "end")
         const mediaCount = data.result_count
-        if (!mediaCount) {
-          page = 1
-        }
-        const errorData = createNoResultErrorData(
-          queryParams.q ?? "",
-          mediaType,
-          mediaCount
-        )
-        this._updateFetchState(mediaType, "end", errorData)
-
         this.setMedia({
           mediaType,
           media: data.results,
@@ -497,17 +484,48 @@ export const useMediaStore = defineStore("media", {
         })
         return mediaCount
       } catch (error: unknown) {
-        const errorData = parseFetchingError(error, mediaType, "search", {
-          searchTerm: queryParams.q ?? "",
-        })
-        this._updateFetchState(mediaType, "end", errorData)
+        this.handleFetchingError(error, mediaType, queryParams.q)
+      }
+    },
 
-        console.warn(error, { extra: errorData })
-        throw createError(errorData)
+    async fetchAndDecode(
+      mediaType: SupportedMediaType,
+      url: string,
+      queryParams: PaginatedSearchQuery | PaginatedCollectionQuery
+    ) {
+      const res = await ofetch.raw<PaginatedApiMediaResult>(url, {
+        params: queryParams,
+        retry: 0,
+        timeout: DEFAULT_REQUEST_TIMEOUT,
+      })
+      const data = this.decodeData(res._data, mediaType)
+      if (!data.result_count) {
+        throw new Error(NO_RESULT)
       }
+      return data
     },
 
-    decodeData(data: PaginatedApiMediaResult, mediaType: SupportedMediaType) {
+    handleFetchingError(
+      error: unknown,
+      mediaType: SupportedMediaType,
+      searchTerm: string
+    ) {
+      const errorData = parseFetchingError(error, mediaType, "search", {
+        searchTerm,
+      })
+      this._updateFetchState(mediaType, "end", errorData)
+
+      console.warn(error, { extra: errorData })
+      throw createError(errorData)
+    },
+
+    decodeData(
+      data: PaginatedApiMediaResult | undefined,
+      mediaType: SupportedMediaType
+    ) {
+      if (!data) {
+        throw new Error("No data to decode")
+      }
       return {
         ...data,
         results: (data.results ?? []).reduce((acc, item) => {
@@ -534,16 +552,6 @@ export const useMediaStore = defineStore("media", {
       return { pathSlug, queryParams }
     },
 
-    getFetchUrl(mediaType: SupportedMediaType, pathSlug: string) {
-      const url = `/api/${mediaSlug(mediaType)}/${pathSlug}`
-
-      // TODO: Check if baseURL works in prod.
-      const nitroOrigin = useRequestEvent()?.context.siteConfigNitroOrigin
-      let baseURL = nitroOrigin ? nitroOrigin : location?.origin
-      baseURL = baseURL.replace("localhost", "0.0.0.0")
-      return { url, baseURL }
-    },
-
     setMediaProperties(
       type: SupportedMediaType,
       id: string,
@@ -577,20 +585,3 @@ const findNoResultError = (errors: FetchingError[]): FetchingError | null => {
     ? { ...errors[0], searchType: ALL_MEDIA }
     : null
 }
-
-export const createNoResultErrorData = (
-  searchTerm: string,
-  mediaType: SupportedMediaType,
-  mediaCount: number
-) => {
-  if (mediaCount) {
-    return undefined
-  }
-  return {
-    message: `No results found for ${searchTerm}`,
-    code: NO_RESULT,
-    requestKind: "search",
-    searchType: mediaType,
-    details: { searchTerm },
-  } as const
-}
diff --git a/frontend/src/stores/media/related-media.ts b/frontend/src/stores/media/related-media.ts
index 3def1f651c6..3b9e0ec4463 100644
--- a/frontend/src/stores/media/related-media.ts
+++ b/frontend/src/stores/media/related-media.ts
@@ -1,13 +1,11 @@
-import { decodeMediaData, useRequestEvent } from "#imports"
+import { decodeMediaData } from "#imports"
 
 import { defineStore } from "pinia"
 
-import axios from "axios"
-
 import { parseFetchingError } from "~/utils/errors"
 import { mediaSlug, DEFAULT_REQUEST_TIMEOUT } from "~/utils/query-utils"
 
-import { FetchingError, FetchState } from "~/types/fetch-state"
+import type { FetchingError, FetchState } from "~/types/fetch-state"
 import type { AudioDetail, ImageDetail, Media } from "~/types/media"
 import type { SupportedMediaType } from "~/constants/media"
 import type { PaginatedApiMediaResult } from "~/types/api"
@@ -49,11 +47,7 @@ export const useRelatedMediaStore = defineStore("related-media", {
       this.fetchState.fetchingError = null
     },
 
-    async fetchMedia(
-      mediaType: SupportedMediaType,
-      id: string,
-      baseUrl?: string
-    ) {
+    async fetchMedia(mediaType: SupportedMediaType, id: string) {
       if (this.mainMediaId === id && this.media.length > 0) {
         return this.media
       }
@@ -64,19 +58,12 @@ export const useRelatedMediaStore = defineStore("related-media", {
       const url = `/api/${mediaSlug(mediaType)}/${id}/related/`
       const params = mediaType === "audio" ? { peaks: true } : {}
 
-      let baseURL = baseUrl ? baseUrl : null
-      if (!baseURL) {
-        const nitroOrigin = useRequestEvent()?.context?.siteConfigNitroOrigin
-        baseURL = nitroOrigin ? nitroOrigin : location?.origin
-        baseURL = baseURL.replace("localhost", "0.0.0.0")
-      }
       try {
-        const res = await axios.get<PaginatedApiMediaResult>(url, {
+        const res = await $fetch.raw<PaginatedApiMediaResult>(url, {
           timeout: DEFAULT_REQUEST_TIMEOUT,
           params,
-          baseURL,
         })
-        this.media = (res.data.results ?? []).map(
+        this.media = (res._data?.results ?? []).map(
           (item: AudioDetail | ImageDetail) => decodeMediaData(item, mediaType)
         )
         this._endFetching()
diff --git a/frontend/src/stores/media/single-result.ts b/frontend/src/stores/media/single-result.ts
index 8c2aeab4489..12a0aaa6662 100644
--- a/frontend/src/stores/media/single-result.ts
+++ b/frontend/src/stores/media/single-result.ts
@@ -1,14 +1,7 @@
-import {
-  createError,
-  decodeMediaData,
-  isServer,
-  useRequestEvent,
-} from "#imports"
+import { createError, decodeMediaData, isServer } from "#imports"
 
 import { defineStore } from "pinia"
 
-import axios from "axios"
-
 import type {
   ApiMedia,
   AudioDetail,
@@ -167,13 +160,8 @@ export const useSingleResultStore = defineStore("single-result", {
         ? existingItem
         : ((await this.fetchMediaItem<T>(type, id)) as DetailFromMediaType<T>)
       if (item && isServer) {
-        const baseURL =
-          useRequestEvent()?.context.siteConfigNitroOrigin.replace(
-            "localhost",
-            "0.0.0.0"
-          )
         const relatedMediaStore = useRelatedMediaStore()
-        await relatedMediaStore.fetchMedia(type, id, baseURL)
+        await relatedMediaStore.fetchMedia(type, id)
       }
       return item
     },
@@ -188,19 +176,15 @@ export const useSingleResultStore = defineStore("single-result", {
     ) {
       this._updateFetchState("start")
 
-      const nitroOrigin = useRequestEvent()?.context.siteConfigNitroOrigin
-
-      let baseURL = nitroOrigin ? nitroOrigin : location?.origin
-      baseURL = baseURL.replace("localhost", "0.0.0.0")
       try {
-        const rawItem = await axios.get<ApiMedia>(
+        const rawItem = await $fetch.raw<ApiMedia>(
           `/api/${mediaSlug(type)}/${id}/`,
           {
             timeout: DEFAULT_REQUEST_TIMEOUT,
-            baseURL,
           }
         )
-        const transformedItem = decodeMediaData(rawItem.data, type)
+
+        const transformedItem = decodeMediaData(rawItem._data, type)
         const item = this._addProviderName(transformedItem)
 
         this.setMediaItem(item)
diff --git a/frontend/src/stores/provider.ts b/frontend/src/stores/provider.ts
index 61339f91a44..372ae841899 100644
--- a/frontend/src/stores/provider.ts
+++ b/frontend/src/stores/provider.ts
@@ -1,15 +1,13 @@
-import { useRuntimeConfig, useRequestEvent } from "#imports"
+import { useRuntimeConfig } from "#imports"
 
 import { defineStore } from "pinia"
 
-import axios from "axios"
-
 import { capitalCase } from "~/utils/case"
 import { parseFetchingError } from "~/utils/errors"
 import {
   AUDIO,
   IMAGE,
-  SupportedMediaType,
+  type SupportedMediaType,
   supportedMediaTypes,
 } from "~/constants/media"
 
@@ -139,18 +137,14 @@ export const useProviderStore = defineStore("provider", {
       this._updateFetchState(mediaType, "start")
       let sortedProviders = [] as MediaProvider[]
 
-      const nitroOrigin = useRequestEvent()?.context.siteConfigNitroOrigin
-      let baseURL = nitroOrigin ? nitroOrigin : location?.origin
-      baseURL = baseURL.replace("localhost", "0.0.0.0")
       try {
-        const res: { data: MediaProvider[] } = await axios.get(
+        const res = await $fetch.raw(
           `/api/${mediaType === "image" ? "images" : "audio"}/stats/`,
           {
-            baseURL,
             timeout: DEFAULT_REQUEST_TIMEOUT,
           }
         )
-        sortedProviders = sortProviders(res.data ?? [])
+        sortedProviders = sortProviders(res._data ?? [])
         this._updateFetchState(mediaType, "end")
       } catch (error: unknown) {
         const errorData = parseFetchingError(error, mediaType, "provider")
diff --git a/frontend/src/utils/decode-media-data.ts b/frontend/src/utils/decode-media-data.ts
index a1ebf4e663d..ca415bd2b05 100644
--- a/frontend/src/utils/decode-media-data.ts
+++ b/frontend/src/utils/decode-media-data.ts
@@ -99,9 +99,12 @@ const parseTags = (tags: Tag[]) => {
  * @returns the given media object with the text fields decoded
  */
 export const decodeMediaData = <T extends Media>(
-  media: ApiMedia,
+  media: ApiMedia | undefined | null,
   mediaType: T["frontendMediaType"]
 ): T => {
+  if (!media) {
+    throw new Error("Media is undefined or null")
+  }
   // Fake ~50% of results as sensitive.
   const featureFlagStore = useFeatureFlagStore()
   const sensitivity =
diff --git a/frontend/src/utils/errors.ts b/frontend/src/utils/errors.ts
index 0d4c3fe5f9e..ae953d3121e 100644
--- a/frontend/src/utils/errors.ts
+++ b/frontend/src/utils/errors.ts
@@ -1,10 +1,8 @@
-import axios from "axios"
+import { FetchError } from "ofetch"
 
 import {
   clientSideErrorCodes,
   ERR_UNKNOWN,
-  ErrorCode,
-  errorCodes,
   NO_RESULT,
 } from "~/constants/errors"
 import type { FetchingError, RequestKind } from "~/types/fetch-state"
@@ -25,28 +23,24 @@ export const parseFetchingError = (
 ) => {
   const fetchingError: FetchingError = {
     requestKind,
-    details,
+    details: details ?? {},
     searchType,
     code: ERR_UNKNOWN,
   }
-
-  if (axios.isAxiosError(error)) {
-    if (isValidErrorCode(error.code)) {
-      fetchingError.code = error.code
-    }
-    if (error.response?.status) {
-      fetchingError.statusCode = error.response.status
+  if (error instanceof Error && error.message === NO_RESULT) {
+    fetchingError.code = NO_RESULT
+    fetchingError.message = "No results found."
+    return fetchingError
+  }
+  if (error instanceof FetchError) {
+    fetchingError.statusCode = error.statusCode
+    fetchingError.message = error.message
+    if (error.statusText) {
+      fetchingError.code = error.statusText
     }
-    const responseData = error?.response?.data
-    // Use the message returned by the API.
-    if (
-      typeof responseData === "object" &&
-      responseData !== null &&
-      "detail" in responseData
-    ) {
-      fetchingError.message = responseData?.detail as string
-    } else {
-      fetchingError.message = error.message
+    fetchingError.details = {
+      ...(fetchingError.details ?? {}),
+      message: error.data.detail,
     }
   } else {
     fetchingError.message = (error as Error).message
@@ -62,15 +56,6 @@ const isNonRetryableErrorStatusCode = (statusCode: number | undefined) => {
   )
 }
 
-const isValidErrorCode = (
-  code: string | undefined | null
-): code is ErrorCode => {
-  if (!code) {
-    return false
-  }
-  return (errorCodes as readonly string[]).includes(code)
-}
-
 /**
  * Returns true if the request should be retried if error occurred on
  * the server. For 429, 500 or 404 errors, or for NO_RESULT error,
diff --git a/frontend/test/unit/specs/stores/media-store-fetching.spec.js b/frontend/test/unit/specs/stores/media-store-fetching.spec.js
index f1ecb26dab0..9e765c359db 100644
--- a/frontend/test/unit/specs/stores/media-store-fetching.spec.js
+++ b/frontend/test/unit/specs/stores/media-store-fetching.spec.js
@@ -1,6 +1,6 @@
 // @vitest-environment jsdom
 // Using jsdom as the test environment because we need to mock axios
-import axios from "axios"
+import { ofetch } from "ofetch"
 
 import { createPinia, setActivePinia } from "~~/test/unit/test-utils/pinia"
 
@@ -11,8 +11,8 @@ import { DEFAULT_REQUEST_TIMEOUT } from "~/utils/query-utils"
 import { useSearchStore } from "~/stores/search"
 
 const DEFAULT_REQUEST_PARAMS = {
-  baseURL: "https://0.0.0.0:8443",
   timeout: DEFAULT_REQUEST_TIMEOUT,
+  retry: 0,
 }
 
 const DEFAULT_ADDITIONAL_MEDIA_PARAMS = (mediaType) => ({
@@ -52,14 +52,6 @@ const items = (mediaType) =>
     tags: [],
   }))
 
-vi.mock("#app/composables/ssr", () => ({
-  useRequestEvent: vi.fn(() => ({
-    context: {
-      siteConfigNitroOrigin: "https://localhost:8443",
-    },
-  })),
-}))
-
 vi.mock("#app/nuxt", async () => {
   const original = await import("#app/nuxt")
   return {
@@ -71,15 +63,14 @@ vi.mock("#app/nuxt", async () => {
     })),
   }
 })
-vi.mock("axios", async (importOriginal) => {
+vi.mock("ofetch", async (importOriginal) => {
   const original = await importOriginal()
   return {
-    default: {
-      ...original,
-      isAxiosError: vi.fn(() => true),
-      get: vi.fn(() =>
+    ...original,
+    ofetch: {
+      raw: vi.fn(() =>
         Promise.resolve({
-          data: { result_count: 10000, page: 1, page_count: 50, results: [] },
+          _data: { result_count: 10000, page: 1, page_count: 50, results: [] },
         })
       ),
     },
@@ -90,7 +81,7 @@ vi.resetModules()
 
 describe("fetchMedia", () => {
   beforeEach(() => {
-    axios.get.mockClear()
+    ofetch.raw.mockClear()
     setActivePinia(createPinia())
   })
 
@@ -102,10 +93,10 @@ describe("fetchMedia", () => {
     const media = await mediaStore.fetchMedia()
 
     expect(media).toEqual([])
-    expect(axios.get).toHaveBeenCalledTimes(2)
+    expect(ofetch.raw).toHaveBeenCalledTimes(2)
 
     // The order of calls is random, so we sort them by URL.
-    const mockCallArgs = axios.get.mock.calls.sort((a, b) =>
+    const mockCallArgs = ofetch.raw.mock.calls.sort((a, b) =>
       a[0].localeCompare(b[0])
     )
     const [[audioUrl, audioParams], [imageUrl, imageParams]] = mockCallArgs
@@ -122,9 +113,9 @@ describe("fetchMedia", () => {
   })
 
   it("fetchMedia should fetch only the specified media type from the API if search type is not ALL_MEDIA", async () => {
-    axios.get.mockImplementation(() =>
+    ofetch.raw.mockImplementation(() =>
       Promise.resolve({
-        data: {
+        _data: {
           result_count: 10000,
           page: 1,
           page_count: 50,
@@ -140,8 +131,8 @@ describe("fetchMedia", () => {
     const media = await mediaStore.fetchMedia()
 
     expect(media.length).toEqual(4)
-    expect(axios.get).toHaveBeenCalledTimes(1)
-    expect(axios.get).toHaveBeenCalledWith("/api/images/", {
+    expect(ofetch.raw).toHaveBeenCalledTimes(1)
+    expect(ofetch.raw).toHaveBeenCalledWith("/api/images/", {
       ...DEFAULT_REQUEST_PARAMS,
       params: {
         q: "cat",
@@ -151,9 +142,9 @@ describe("fetchMedia", () => {
   })
 
   it("fetchMedia fetches the next page of results", async () => {
-    axios.get.mockImplementation(() =>
+    ofetch.raw.mockImplementation(() =>
       Promise.resolve({
-        data: {
+        _data: {
           result_count: 10000,
           page: 1,
           page_count: 50,
@@ -170,7 +161,7 @@ describe("fetchMedia", () => {
     await mediaStore.fetchMedia({ shouldPersistMedia: true })
 
     expect(mediaStore.currentPage).toEqual(3)
-    expect(axios.get).toHaveBeenCalledWith("/api/images/", {
+    expect(ofetch.raw).toHaveBeenCalledWith("/api/images/", {
       ...DEFAULT_REQUEST_PARAMS,
       params: {
         page: "3",
@@ -180,9 +171,9 @@ describe("fetchMedia", () => {
   })
 
   it("fetchMedia handles rejected promises", async () => {
-    axios.get.mockImplementation(() =>
+    ofetch.raw.mockImplementation(() =>
       Promise.resolve({
-        data: { result_count: 10000, page: 1, page_count: 50, results: items },
+        _data: { result_count: 10000, page: 1, page_count: 50, results: items },
       })
     )
 
@@ -199,14 +190,14 @@ describe("fetchMedia", () => {
 
 describe("fetchSingleMediaType", () => {
   beforeEach(() => {
-    axios.get.mockClear()
+    ofetch.raw.mockClear()
     setActivePinia(createPinia())
   })
 
   it("fetchSingleMediaType should fetch a single media from the API", async () => {
-    axios.get.mockImplementation(() =>
+    ofetch.raw.mockImplementation(() =>
       Promise.resolve({
-        data: { result_count: 10000, page: 1, page_count: 50, results: [] },
+        _data: { result_count: 10000, page: 1, page_count: 50, results: [] },
       })
     )
     const mediaStore = useMediaStore()
@@ -216,7 +207,7 @@ describe("fetchSingleMediaType", () => {
     })
 
     expect(media).toEqual(10000)
-    expect(axios.get).toHaveBeenCalledWith("/api/images/", {
+    expect(ofetch.raw).toHaveBeenCalledWith("/api/images/", {
       ...DEFAULT_REQUEST_PARAMS,
       params: {
         q: "",
@@ -225,9 +216,9 @@ describe("fetchSingleMediaType", () => {
   })
 
   it("fetchSingleMediaType augments item returned from the API", async () => {
-    axios.get.mockImplementation(() =>
+    ofetch.raw.mockImplementation(() =>
       Promise.resolve({
-        data: {
+        _data: {
           result_count: 1,
           page: 1,
           page_count: 1,
@@ -249,16 +240,16 @@ describe("fetchSingleMediaType", () => {
       ...DEFAULT_ADDITIONAL_MEDIA_PARAMS(IMAGE),
     })
 
-    expect(axios.get).toHaveBeenCalledWith("/api/images/", {
+    expect(ofetch.raw).toHaveBeenCalledWith("/api/images/", {
       params: { q: "" },
       ...DEFAULT_REQUEST_PARAMS,
     })
   })
 
-  it("fetchSingleMediaType handles no results", async () => {
-    axios.get.mockImplementation(() =>
+  it("fetchSingleMediaType throws an error no results", async () => {
+    ofetch.raw.mockImplementation(() =>
       Promise.resolve({
-        data: {
+        _data: {
           result_count: 0,
           page: 1,
           page_count: 0,
@@ -268,12 +259,15 @@ describe("fetchSingleMediaType", () => {
     )
 
     const mediaStore = useMediaStore()
-    const media = await mediaStore.fetchSingleMediaType({
-      mediaType: IMAGE,
-      shouldPersistMedia: false,
-    })
+    await expect(async () =>
+      mediaStore.fetchSingleMediaType({
+        mediaType: IMAGE,
+        shouldPersistMedia: false,
+      })
+    ).rejects.toThrowError("No results found")
 
-    expect(media).toEqual(0)
+    const media = mediaStore.results.image.items
+    expect(Object.keys(media).length).toEqual(0)
 
     expect(mediaStore.fetchState).toEqual({
       fetchingError: null,
diff --git a/frontend/test/unit/specs/stores/media-store.spec.js b/frontend/test/unit/specs/stores/media-store.spec.js
index 97d03590568..0d5d91d5d9f 100644
--- a/frontend/test/unit/specs/stores/media-store.spec.js
+++ b/frontend/test/unit/specs/stores/media-store.spec.js
@@ -6,11 +6,7 @@ import { image as imageObject } from "~~/test/unit/fixtures/image"
 
 import { deepClone } from "~/utils/clone"
 
-import {
-  createNoResultErrorData,
-  initialResults,
-  useMediaStore,
-} from "~/stores/media"
+import { initialResults, useMediaStore } from "~/stores/media"
 import { useSearchStore } from "~/stores/search"
 import {
   ALL_MEDIA,
@@ -461,15 +457,6 @@ describe("media store", () => {
     }
   )
 
-  it("getFetchUrl returns default values", () => {
-    const mediaStore = useMediaStore()
-    const { url, baseURL } = mediaStore.getFetchUrl("image", "")
-
-    expect(baseURL).toEqual("http://0.0.0.0:3000")
-
-    expect(url).toEqual(`/api/images/`)
-  })
-
   it("decodeData returns correct data", () => {
     const mediaStore = useMediaStore()
     const apiResult = testApiResult(IMAGE)
@@ -491,23 +478,4 @@ describe("media store", () => {
       expect(data.results[id].originalTitle).toEqual(item.title)
     }
   })
-
-  it.each`
-    searchTerm | mediaType | mediaCount | expectedData
-    ${"cat"}   | ${IMAGE}  | ${0}       | ${{ code: NO_RESULT, details: { searchTerm: "cat" }, message: "No results found for cat", requestKind: "search", searchType: IMAGE }}
-    ${"cat"}   | ${AUDIO}  | ${0}       | ${{ code: NO_RESULT, details: { searchTerm: "cat" }, message: "No results found for cat", requestKind: "search", searchType: AUDIO }}
-    ${"cat"}   | ${IMAGE}  | ${1}       | ${undefined}
-    ${"cat"}   | ${AUDIO}  | ${1}       | ${undefined}
-  `(
-    "createNoResultErrorData returns correct data",
-    ({ searchTerm, mediaType, mediaCount, expectedData }) => {
-      const actualErrorData = createNoResultErrorData(
-        searchTerm,
-        mediaType,
-        mediaCount
-      )
-
-      expect(actualErrorData).toEqual(expectedData)
-    }
-  )
 })