diff --git a/Changelog b/Changelog
index 042f69bf..7a593971 100644
--- a/Changelog
+++ b/Changelog
@@ -1,6 +1,10 @@
 Unreleased:
 * FIX: Ensure AWS SDK has access to object size when issuing an upload (@benoit #2117)
 * FIX: Change log level of S3 missing keys message (@benoit #2144)
+* FIX: Logic to set .webp path prefix on reencoded images is skewed (@benoit74 #2140)
+* FIX: S3 cached images are missing (@benoit74 #2136)
+* FIX: Do not rely on URL filename extension to detect images (@benoit74 #2088)
+* FIX: S3 cached image are never used (@benoit74 #2138)
 
 1.14.0:
 * FIX: Remove S3 upload concurrency to avoid 'RequestTimeTooSkewed' errors (@benoi74 #2118)
diff --git a/package-lock.json b/package-lock.json
index 4d12faf3..675107ac 100644
--- a/package-lock.json
+++ b/package-lock.json
@@ -1,12 +1,12 @@
 {
   "name": "mwoffliner",
-  "version": "1.14.0",
+  "version": "1.14.1-dev0",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "mwoffliner",
-      "version": "1.14.0",
+      "version": "1.14.1-dev0",
       "license": "GPL-3.0",
       "dependencies": {
         "@aws-sdk/client-s3": "^3.374.0",
@@ -45,7 +45,6 @@
         "imagemin-webp": "^7.0.0",
         "md5": "^2.3.0",
         "merge": "^2.1.1",
-        "mime-type": "^4.0.0",
         "mkdirp": "^2.1.6",
         "mocha": "^10.2.0",
         "p-map": "^5.5.0",
@@ -10446,11 +10445,6 @@
       "resolved": "https://registry.npmjs.org/inherits/-/inherits-2.0.4.tgz",
       "integrity": "sha512-k/vGaX4/Yla3WzyMCvTQOXYeIHvqOKtnqBduzTHpzpQZzAskKMhZ2K+EnBiSM9zGSoIFeMpXKxa4dYeZIQqewQ=="
     },
-    "node_modules/inherits-ex": {
-      "version": "1.6.0",
-      "resolved": "https://registry.npmjs.org/inherits-ex/-/inherits-ex-1.6.0.tgz",
-      "integrity": "sha512-67sANrSoIvMmYDy0qyjmM/PvFdgBmWZVQoPBsRpDuP4tmlylEX1KdGN1bHvReG3eHBdaHY7WlZsrqys4y/cLVA=="
-    },
     "node_modules/ini": {
       "version": "1.3.8",
       "resolved": "https://registry.npmjs.org/ini/-/ini-1.3.8.tgz",
@@ -13534,19 +13528,6 @@
         "node": ">= 0.6"
       }
     },
-    "node_modules/mime-type": {
-      "version": "4.0.0",
-      "resolved": "https://registry.npmjs.org/mime-type/-/mime-type-4.0.0.tgz",
-      "integrity": "sha512-1FCc9fsTg44pd7koB486WEepve+sc4847F0USUf08j4+bAU6/9ckIq4kHVEhCxbxHCyUZy++dxx/PtSR/m4XBQ==",
-      "dependencies": {
-        "micromatch": "^4.0.2",
-        "path.js": "^1.0.7",
-        "util-ex": "^0.3.15"
-      },
-      "engines": {
-        "node": ">= 8.6"
-      }
-    },
     "node_modules/mime-types": {
       "version": "2.1.35",
       "resolved": "https://registry.npmjs.org/mime-types/-/mime-types-2.1.35.tgz",
@@ -15042,24 +15023,6 @@
         "node": ">=8"
       }
     },
-    "node_modules/path.js": {
-      "version": "1.0.7",
-      "resolved": "https://registry.npmjs.org/path.js/-/path.js-1.0.7.tgz",
-      "integrity": "sha512-DPX1vNSmckC3figW8xT/fEuF+XBg/96RUpXfW0yT6UGHgQI2mtTSADflz45bXKREbz+5GJa0qDQGNIpNr1skRQ==",
-      "dependencies": {
-        "escape-string-regexp": "^1.0.3",
-        "inherits-ex": "^1.1.2",
-        "util-ex": "^0.3.10"
-      }
-    },
-    "node_modules/path.js/node_modules/escape-string-regexp": {
-      "version": "1.0.5",
-      "resolved": "https://registry.npmjs.org/escape-string-regexp/-/escape-string-regexp-1.0.5.tgz",
-      "integrity": "sha512-vbRorB5FUQWvla16U8R/qgaFIya2qGzwDrNmCZuYKrbdSUMG6I1ZCGQRefkRVhuOkIGVne7BQ35DSfo1qvJqFg==",
-      "engines": {
-        "node": ">=0.8.0"
-      }
-    },
     "node_modules/peek-readable": {
       "version": "5.0.0",
       "resolved": "https://registry.npmjs.org/peek-readable/-/peek-readable-5.0.0.tgz",
@@ -18996,15 +18959,6 @@
       "resolved": "https://registry.npmjs.org/util-deprecate/-/util-deprecate-1.0.2.tgz",
       "integrity": "sha512-EPD5q1uXyFxJpCrLnCc1nHnq3gOa6DZBocAIiI2TaSCA7VCJ1UJDMagCzIkXNsUYfD1daK//LTEQ8xiIbrHtcw=="
     },
-    "node_modules/util-ex": {
-      "version": "0.3.18",
-      "resolved": "https://registry.npmjs.org/util-ex/-/util-ex-0.3.18.tgz",
-      "integrity": "sha512-GPVjD257DtgCDMHYqbdWvZ+RY3HaXZ7Dps/44de5WscOjFNL2Qr+6dTIKGlyfA4A5BXyeFKWy8mb19OATWhh8Q==",
-      "dependencies": {
-        "inherits-ex": "^1.5.2",
-        "xtend": "^4.0.2"
-      }
-    },
     "node_modules/uuid": {
       "version": "8.3.2",
       "resolved": "https://registry.npmjs.org/uuid/-/uuid-8.3.2.tgz",
diff --git a/package.json b/package.json
index 3001f19f..1808e3b3 100644
--- a/package.json
+++ b/package.json
@@ -94,7 +94,6 @@
     "imagemin-webp": "^7.0.0",
     "md5": "^2.3.0",
     "merge": "^2.1.1",
-    "mime-type": "^4.0.0",
     "mkdirp": "^2.1.6",
     "mocha": "^10.2.0",
     "p-map": "^5.5.0",
diff --git a/src/Downloader.ts b/src/Downloader.ts
index ca646146..a7e65a3b 100644
--- a/src/Downloader.ts
+++ b/src/Downloader.ts
@@ -15,8 +15,9 @@ import imageminWebp from 'imagemin-webp'
 import sharp from 'sharp'
 import http from 'http'
 import https from 'https'
+import { fileTypeFromBuffer } from 'file-type'
 
-import { normalizeMwResponse, DB_ERROR, WEAK_ETAG_REGEX, stripHttpFromUrl, isBitmapImageMimeType, isImageUrl, getMimeType, isWebpCandidateImageMimeType } from './util/index.js'
+import { normalizeMwResponse, DB_ERROR, WEAK_ETAG_REGEX, stripHttpFromUrl, isBitmapImageMimeType, isWebpCandidateImageMimeType } from './util/index.js'
 import S3 from './S3.js'
 import * as logger from './Logger.js'
 import MediaWiki, { QueryOpts } from './MediaWiki.js'
@@ -68,6 +69,10 @@ interface BackoffOptions {
   backoffHandler: (number: number, delay: number, error?: any) => void
 }
 
+interface CompressionData {
+  data: any
+}
+
 export const defaultStreamRequestOptions: AxiosRequestConfig = {
   headers: {
     accept: 'application/octet-stream',
@@ -353,7 +358,7 @@ class Downloader {
     const url = urlHelper.deserializeUrl(_url)
     await this.claimRequest()
     return new Promise<T>((resolve, reject) => {
-      this.backoffCall(this.getJSONCb, url, (err: any, val: any) => {
+      this.backoffCall(this.getJSONCb, url, 'json', (err: any, val: any) => {
         this.releaseRequest()
         if (err) {
           const httpStatus = err.response && err.response.status
@@ -366,7 +371,7 @@ class Downloader {
     })
   }
 
-  public async downloadContent(_url: string, retry = true): Promise<{ content: Buffer | string; responseHeaders: any }> {
+  public async downloadContent(_url: string, kind: string, retry = true): Promise<{ content: Buffer | string; contentType: string; setCookie: string | null }> {
     if (!_url) {
       throw new Error(`Parameter [${_url}] is not a valid url`)
     }
@@ -384,9 +389,9 @@ class Downloader {
           }
         }
         if (retry) {
-          this.backoffCall(this.getContentCb, url, cb)
+          this.backoffCall(this.getContentCb, url, kind, cb)
         } else {
-          this.getContentCb(url, cb)
+          this.getContentCb(url, kind, cb)
         }
       })
     } catch (err) {
@@ -454,7 +459,7 @@ class Downloader {
     return null
   }
 
-  private getJSONCb = <T>(url: string, handler: (...args: any[]) => any): void => {
+  private getJSONCb = <T>(url: string, kind: string, handler: (...args: any[]) => any): void => {
     logger.info(`Getting JSON from [${url}]`)
     axios
       .get<T>(url, this.jsonRequestOptions)
@@ -466,7 +471,7 @@ class Downloader {
             const newMaxActiveRequests: number = Math.max(this.maxActiveRequests - 1, 1)
             logger.log(`Setting maxActiveRequests from [${this.maxActiveRequests}] to [${newMaxActiveRequests}]`)
             this.maxActiveRequests = newMaxActiveRequests
-            return this.getJSONCb(url, handler)
+            return this.getJSONCb(url, kind, handler)
           } else if (err.response && err.response.status === 404) {
             handler(err)
           }
@@ -477,56 +482,68 @@ class Downloader {
       })
   }
 
-  private async getCompressedBody(resp: any): Promise<any> {
-    if (isBitmapImageMimeType(resp.headers['content-type'])) {
-      if (isWebpCandidateImageMimeType(this.webp, resp.headers['content-type']) && !this.cssDependenceUrls.hasOwnProperty(resp.config.url)) {
-        resp.data = await (imagemin as any)
-          .buffer(resp.data, imageminOptions.get('webp').get(resp.headers['content-type']))
-          .catch(async (err) => {
-            if (/Unsupported color conversion request/.test(err.stderr)) {
-              return (imagemin as any)
-                .buffer(await sharp(resp.data).toColorspace('srgb').toBuffer(), imageminOptions.get('webp').get(resp.headers['content-type']))
-                .catch(() => {
-                  return resp.data
-                })
-                .then((data) => {
-                  resp.headers['content-type'] = 'image/webp'
-                  return data
+  private async getImageMimeType(data: any): Promise<string | null> {
+    const fileType = await fileTypeFromBuffer(data)
+    return fileType ? fileType.mime : null
+  }
+
+  private async getCompressedBody(input: CompressionData): Promise<CompressionData> {
+    const contentType = await this.getImageMimeType(input.data)
+    if (isBitmapImageMimeType(contentType)) {
+      if (this.webp && isWebpCandidateImageMimeType(contentType)) {
+        return {
+          data: await (imagemin as any)
+            .buffer(input.data, imageminOptions.get('webp').get(contentType))
+            .catch(async (err) => {
+              if (/Unsupported color conversion request/.test(err.stderr)) {
+                return (imagemin as any)
+                  .buffer(await sharp(input.data).toColorspace('srgb').toBuffer(), imageminOptions.get('webp').get(contentType))
+                  .catch(() => {
+                    return input.data
+                  })
+                  .then((data) => {
+                    return data
+                  })
+              } else {
+                return (imagemin as any).buffer(input.data, imageminOptions.get('default').get(contentType)).catch(() => {
+                  return input.data
                 })
-            } else {
-              return (imagemin as any).buffer(resp.data, imageminOptions.get('default').get(resp.headers['content-type'])).catch(() => {
-                return resp.data
-              })
-            }
-          })
-          .then((data) => {
-            resp.headers['content-type'] = 'image/webp'
-            return data
-          })
-        resp.headers.path_postfix = '.webp'
+              }
+            })
+            .then((data) => {
+              return data
+            }),
+        }
       } else {
-        resp.data = await (imagemin as any).buffer(resp.data, imageminOptions.get('default').get(resp.headers['content-type'])).catch(() => {
-          return resp.data
-        })
+        return {
+          data: await (imagemin as any).buffer(input.data, imageminOptions.get('default').get(contentType)).catch(() => {
+            return input.data
+          }),
+        }
       }
-      return true
     }
-    return false
+    return {
+      data: input.data,
+    }
   }
 
-  private getContentCb = async (url: string, handler: any): Promise<void> => {
+  private getContentCb = async (url: string, kind: string, handler: any): Promise<void> => {
     logger.info(`Downloading [${url}]`)
     try {
-      if (this.optimisationCacheUrl && isImageUrl(url)) {
+      if (this.optimisationCacheUrl && kind === 'image') {
         this.downloadImage(url, handler)
       } else {
         // Use the base domain of the wiki being scraped as the Referer header, so that we can
         // successfully scrap WMF map tiles.
-        const resp = await axios(url, { ...this.arrayBufferRequestOptions, headers: { Referer: MediaWiki.baseUrl.href } })
-        await this.getCompressedBody(resp)
+        const resp = await axios(url, { ...this.arrayBufferRequestOptions, headers: { ...this.arrayBufferRequestOptions.headers, Referer: MediaWiki.baseUrl.href } })
+        // If content is an image, we might benefit from compressing it
+        const content = kind === 'image' ? (await this.getCompressedBody({ data: resp.data })).data : resp.data
+        // compute content-type from content, since getCompressedBody might have modified it
+        const contentType = kind === 'image' ? (await this.getImageMimeType(content)) || resp.headers['content-type'] : resp.headers['content-type']
         handler(null, {
-          responseHeaders: resp.headers,
-          content: resp.data,
+          contentType,
+          content,
+          setCookie: resp.headers['set-cookie'] ? resp.headers['set-cookie'].join(';') : null,
         })
       }
     } catch (err) {
@@ -555,46 +572,44 @@ class Downloader {
           }
           // Use the base domain of the wiki being scraped as the Referer header, so that we can
           // successfully scrap WMF map tiles.
-          const mwResp = await axios(url, { ...this.arrayBufferRequestOptions, headers: { Referer: MediaWiki.baseUrl.href } })
-
-          // HTTP response content-type can not really be trusted (at least if 304)
-          mwResp.headers['content-type'] = getMimeType(url, s3Resp?.Metadata?.contenttype || mwResp.headers['content-type'])
+          const mwResp = await axios(url, { ...this.arrayBufferRequestOptions, headers: { ...this.arrayBufferRequestOptions.headers, Referer: MediaWiki.baseUrl.href } })
 
           // Most of the images, after having been uploaded once to the
           // cache, will always have 304 status, until modified. If cache
           // is up to date, return cached image.
           if (mwResp.status === 304) {
-            // eslint-disable-next-line @typescript-eslint/no-unused-vars
-            const headers = (({ Body, ...o }) => o)(s3Resp)
-
-            // If image is a webp conversion candidate
-            if (isWebpCandidateImageMimeType(this.webp, mwResp.headers['content-type']) && !this.cssDependenceUrls.hasOwnProperty(mwResp.config.url)) {
-              headers.path_postfix = '.webp'
-              headers['content-type'] = 'image/webp'
-            }
-
             // Proceed with image
+            const data = (await this.streamToBuffer(s3Resp.Body as Readable)) as any
+            const contentType = await this.getImageMimeType(data)
+            logger.info(`Using S3-cached image for ${url} (contentType: ${contentType})`)
             handler(null, {
-              responseHeaders: headers,
-              content: (await this.streamToBuffer(s3Resp.Body as Readable)) as any,
+              contentType,
+              content: data,
             })
-
             return
           }
 
           // Compress content because image blob comes from upstream MediaWiki
-          await this.getCompressedBody(mwResp)
+          const compressedData = (await this.getCompressedBody({ data: mwResp.data })).data
 
           // Check for the ETag and upload to cache
           const etag = this.removeEtagWeakPrefix(mwResp.headers.etag)
           if (etag) {
-            await this.s3.uploadBlob(stripHttpFromUrl(url), mwResp.data, etag, mwResp.headers['content-type'], this.webp ? 'webp' : '1')
+            await this.s3.uploadBlob(stripHttpFromUrl(url), compressedData, etag, this.webp ? 'webp' : '1')
+          }
+
+          // get contentType from image, with fallback to response headers should the image be unsupported at all (e.g. SVG)
+          const contentType = (await this.getImageMimeType(compressedData)) || mwResp.headers['content-type']
+          if (s3Resp) {
+            logger.info(`Using image downloaded from upstream for ${url} (S3-cached image is outdated, contentType: ${contentType})`)
+          } else {
+            logger.info(`Using image downloaded from upstream for ${url} (no S3-cached image found, contentType: ${contentType})`)
           }
 
           // Proceed with image
           handler(null, {
-            responseHeaders: mwResp.headers,
-            content: mwResp.data,
+            contentType,
+            content: compressedData,
           })
         })
         .catch((err) => {
@@ -630,8 +645,8 @@ class Downloader {
     }
   }
 
-  private backoffCall(handler: (...args: any[]) => void, url: string, callback: (...args: any[]) => void | Promise<void>): void {
-    const call = backoff.call(handler, url, callback)
+  private backoffCall(handler: (...args: any[]) => void, url: string, kind: string, callback: (...args: any[]) => void | Promise<void>): void {
+    const call = backoff.call(handler, url, kind, callback)
     call.setStrategy(this.backoffOptions.strategy)
     call.retryIf(this.backoffOptions.retryIf)
     call.failAfter(this.backoffOptions.failAfter)
diff --git a/src/Dump.ts b/src/Dump.ts
index f467bbea..3b160427 100644
--- a/src/Dump.ts
+++ b/src/Dump.ts
@@ -202,7 +202,7 @@ export class Dump {
     const sheetUrls: Array<string | DominoElement> = []
 
     /* Load main page to see which CSS files are needed */
-    const { content } = await downloader.downloadContent(this.mwMetaData.webUrl)
+    const { content } = await downloader.downloadContent(this.mwMetaData.webUrl, 'data')
     const html = content.toString()
     const doc = domino.createDocument(html)
     const links = Array.from(doc.getElementsByTagName('link'))
diff --git a/src/MediaWiki.ts b/src/MediaWiki.ts
index 0efcc958..e4045203 100644
--- a/src/MediaWiki.ts
+++ b/src/MediaWiki.ts
@@ -270,7 +270,7 @@ class MediaWiki {
       }
 
       // Getting token to login.
-      const { content, responseHeaders } = await downloader.downloadContent(url + 'action=query&meta=tokens&type=login&format=json&formatversion=2')
+      const { content, setCookie } = await downloader.downloadContent(url + 'action=query&meta=tokens&type=login&format=json&formatversion=2', 'data')
 
       // Logging in
       await axios(this.actionApiUrl.href, {
@@ -282,7 +282,7 @@ class MediaWiki {
           lgtoken: JSON.parse(content.toString()).query.tokens.logintoken,
         }),
         headers: {
-          Cookie: responseHeaders['set-cookie'].join(';'),
+          Cookie: setCookie,
           'Content-Type': 'application/x-www-form-urlencoded',
         },
         method: 'POST',
@@ -388,7 +388,7 @@ class MediaWiki {
 
   public async getTextDirection(downloader: Downloader): Promise<TextDirection> {
     logger.log('Getting text direction...')
-    const { content } = await downloader.downloadContent(this.webUrl.href)
+    const { content } = await downloader.downloadContent(this.webUrl.href, 'data')
     const body = content.toString()
     const doc = domino.createDocument(body)
     const contentNode = doc.getElementById('mw-content-text')
@@ -458,7 +458,7 @@ class MediaWiki {
 
   public async getSubTitle(downloader: Downloader) {
     logger.log('Getting sub-title...')
-    const { content } = await downloader.downloadContent(this.webUrl.href)
+    const { content } = await downloader.downloadContent(this.webUrl.href, 'data')
     const html = content.toString()
     const doc = domino.createDocument(html)
     const subTitleNode = doc.getElementById('siteSub')
diff --git a/src/S3.ts b/src/S3.ts
index f5adc318..d510ac2b 100644
--- a/src/S3.ts
+++ b/src/S3.ts
@@ -65,11 +65,11 @@ class S3 {
     })
   }
 
-  public uploadBlob(key: string, data: any, eTag: string, contentType: string, version: string): Promise<any> {
+  public uploadBlob(key: string, data: any, eTag: string, version: string): Promise<any> {
     const command = new PutObjectCommand({
       Bucket: this.bucketName,
       Key: key,
-      Metadata: { etag: eTag, contenttype: contentType, version },
+      Metadata: { etag: eTag, version },
       Body: data,
     })
 
diff --git a/src/mwoffliner.lib.ts b/src/mwoffliner.lib.ts
index 43b9ac45..13b361db 100644
--- a/src/mwoffliner.lib.ts
+++ b/src/mwoffliner.lib.ts
@@ -414,7 +414,7 @@ async function execute(argv: any) {
     await getThumbnailsData()
 
     logger.log('Getting Main Page')
-    await getMainPage(dump, zimCreator, downloader)
+    await getMainPage(dump, zimCreator)
 
     logger.log('Getting articles')
     stime = Date.now()
@@ -527,7 +527,7 @@ async function execute(argv: any) {
 
     const parsedUrl = urlParser.parse(entries.logo)
     const logoUrl = parsedUrl.protocol ? entries.logo : MediaWiki.baseUrl.protocol + entries.logo
-    const { content } = await downloader.downloadContent(logoUrl)
+    const { content } = await downloader.downloadContent(logoUrl, 'image')
     return sharp(content).resize(48, 48, { fit: sharp.fit.inside, withoutEnlargement: true }).png().toBuffer()
   }
 
@@ -541,7 +541,7 @@ async function execute(argv: any) {
     }
   }
 
-  function getMainPage(dump: Dump, zimCreator: ZimCreator, downloader: Downloader) {
+  function getMainPage(dump: Dump, zimCreator: ZimCreator) {
     async function createMainPage() {
       logger.log('Creating main page...')
       const doc = domino.createDocument(
@@ -579,7 +579,7 @@ async function execute(argv: any) {
       }
 
       if (articlesWithImages.length > MIN_IMAGE_THRESHOLD_ARTICLELIST_PAGE) {
-        const articlesWithImagesEl = articlesWithImages.map((article) => makeArticleImageTile(dump, article, downloader.webp)).join('\n')
+        const articlesWithImagesEl = articlesWithImages.map((article) => makeArticleImageTile(dump, article)).join('\n')
         doc.body.innerHTML = `<div id='container'><div id='content'>${articlesWithImagesEl}</div></div>`
       } else {
         const articlesWithoutImagesEl = allArticles.map((article) => makeArticleListItem(dump, article)).join('\n')
@@ -623,7 +623,10 @@ async function execute(argv: any) {
 
     articleDetail.internalThumbnailUrl = getRelativeFilePath('Main_Page', getMediaBase(suitableResUrl, true), 'I')
 
-    await Promise.all([filesToDownloadXPath.set(path, { url: urlHelper.serializeUrl(suitableResUrl), mult, width } as FileDetail), articleDetailXId.set(articleId, articleDetail)])
+    await Promise.all([
+      filesToDownloadXPath.set(path, { url: urlHelper.serializeUrl(suitableResUrl), mult, width, kind: 'image' } as FileDetail),
+      articleDetailXId.set(articleId, articleDetail),
+    ])
   }
 
   async function getThumbnailsData(): Promise<void> {
diff --git a/src/renderers/abstract.renderer.ts b/src/renderers/abstract.renderer.ts
index 039a7e93..e49a7576 100644
--- a/src/renderers/abstract.renderer.ts
+++ b/src/renderers/abstract.renderer.ts
@@ -10,16 +10,7 @@ import { config } from '../config.js'
 import { Dump } from '../Dump.js'
 import { rewriteUrlsOfDoc } from '../util/rewriteUrls.js'
 import { footerTemplate } from '../Templates.js'
-import {
-  getFullUrl,
-  getMediaBase,
-  getMimeType,
-  getRelativeFilePath,
-  isWebpCandidateImageMimeType,
-  interpolateTranslationString,
-  encodeArticleIdForZimHtmlUrl,
-  getStaticFiles,
-} from '../util/misc.js'
+import { getFullUrl, getMediaBase, getRelativeFilePath, interpolateTranslationString, encodeArticleIdForZimHtmlUrl, getStaticFiles } from '../util/misc.js'
 
 type renderType = 'auto' | 'desktop' | 'mobile' | 'specific'
 type renderName = 'VisualEditor' | 'WikimediaDesktop' | 'WikimediaMobile' | 'RestApi'
@@ -42,7 +33,6 @@ export type RendererBuilderOptions = RendererBuilderOptionsCommon | RendererBuil
 
 export interface RenderOpts {
   data?: any
-  webp: boolean
   _moduleDependencies: any
   articleId?: string
   articleDetailXId?: RKVS<ArticleDetail>
@@ -55,6 +45,8 @@ export interface RenderSingleOutput {
   articleId: string
   displayTitle: string
   html: string
+  imageDependencies: any
+  videoDependencies: any
   mediaDependencies: any
   moduleDependencies: any
   staticFiles: string[]
@@ -76,14 +68,14 @@ export abstract class Renderer {
     srcCache: KVS<boolean>,
     articleId: string,
     videoEl: DominoElement,
-    webp: boolean,
-  ): Promise<{ mediaDependencies: string[]; subtitles: string[] }> {
-    const mediaDependencies: string[] = []
+  ): Promise<{ imageDependencies: string[]; videoDependencies: string[]; subtitles: string[] }> {
+    const imageDependencies: string[] = []
+    const videoDependencies: string[] = []
     const subtitles: string[] = []
 
     if (dump.nopic || dump.novid || dump.nodet) {
       DOMUtils.deleteNode(videoEl)
-      return { mediaDependencies, subtitles }
+      return { imageDependencies, videoDependencies, subtitles }
     }
 
     this.adjustVideoElementAttributes(videoEl)
@@ -93,18 +85,18 @@ export abstract class Renderer {
     if (!chosenVideoSourceEl) {
       logger.warn(`Unable to find an appropriate video/audio source for an media element in article '${articleId}'`)
       DOMUtils.deleteNode(videoEl)
-      return { mediaDependencies, subtitles }
+      return { imageDependencies, videoDependencies, subtitles }
     }
 
-    this.handleVideoPoster(videoEl, articleId, webp, mediaDependencies, srcCache)
-    this.updateVideoSrc(chosenVideoSourceEl, articleId, srcCache, mediaDependencies)
+    this.handleVideoPoster(videoEl, articleId, imageDependencies, srcCache)
+    this.updateVideoSrc(chosenVideoSourceEl, articleId, srcCache, videoDependencies)
 
     const trackElements = Array.from(videoEl.querySelectorAll('track'))
     for (const track of trackElements) {
       subtitles.push(await this.treatSubtitle(track, articleId))
     }
 
-    return { mediaDependencies, subtitles }
+    return { imageDependencies, videoDependencies, subtitles }
   }
 
   private adjustVideoElementAttributes(videoEl: DominoElement): void {
@@ -187,30 +179,30 @@ export abstract class Renderer {
     return chosenVideoSourceEl
   }
 
-  private handleVideoPoster(videoEl: DominoElement, articleId: string, webp: boolean, mediaDependencies: string[], srcCache: KVS<boolean>): void {
+  private handleVideoPoster(videoEl: DominoElement, articleId: string, imageDependencies: string[], srcCache: KVS<boolean>): void {
     const posterUrl = videoEl.getAttribute('poster')
     if (posterUrl) {
       const videoPosterUrl = getFullUrl(posterUrl, MediaWiki.baseUrl)
       const newVideoPosterUrl = getRelativeFilePath(articleId, getMediaBase(videoPosterUrl, true), 'I')
 
       if (posterUrl) {
-        videoEl.setAttribute('poster', isWebpCandidateImageMimeType(webp, getMimeType(newVideoPosterUrl)) ? newVideoPosterUrl + '.webp' : newVideoPosterUrl)
+        videoEl.setAttribute('poster', newVideoPosterUrl)
       }
       videoEl.removeAttribute('resource')
 
       if (!srcCache.hasOwnProperty(videoPosterUrl)) {
         srcCache[videoPosterUrl] = true
-        mediaDependencies.push(videoPosterUrl)
+        imageDependencies.push(videoPosterUrl)
       }
     }
   }
 
-  private updateVideoSrc(chosenVideoSourceEl: DominoElement, articleId: string, srcCache: KVS<boolean>, mediaDependencies: string[]): void {
+  private updateVideoSrc(chosenVideoSourceEl: DominoElement, articleId: string, srcCache: KVS<boolean>, videoDependencies: string[]): void {
     /* Download content, but avoid duplicate calls */
     const sourceUrl = getFullUrl(chosenVideoSourceEl.getAttribute('src'), MediaWiki.baseUrl)
     if (!srcCache.hasOwnProperty(sourceUrl)) {
       srcCache[sourceUrl] = true
-      mediaDependencies.push(sourceUrl)
+      videoDependencies.push(sourceUrl)
     }
 
     /* Set new URL for the video element */
@@ -261,12 +253,12 @@ export abstract class Renderer {
     imageNode.parentNode.replaceChild(thumbDiv, imageNode)
   }
 
-  private async treatImage(dump: Dump, srcCache: KVS<boolean>, articleId: string, img: DominoElement, webp: boolean): Promise<{ mediaDependencies: string[] }> {
-    const mediaDependencies: string[] = []
+  private async treatImage(dump: Dump, srcCache: KVS<boolean>, articleId: string, img: DominoElement): Promise<{ imageDependencies: string[] }> {
+    const imageDependencies: string[] = []
 
     if (!this.shouldKeepImage(dump, img)) {
       DOMUtils.deleteNode(img)
-      return { mediaDependencies }
+      return { imageDependencies }
     }
 
     /* Remove image link */
@@ -287,7 +279,7 @@ export abstract class Renderer {
           linkNode.parentNode.replaceChild(img, linkNode)
         } else {
           DOMUtils.deleteNode(img)
-          return { mediaDependencies }
+          return { imageDependencies }
         }
       }
     }
@@ -303,11 +295,11 @@ export abstract class Renderer {
       /* Download image, but avoid duplicate calls */
       if (!srcCache.hasOwnProperty(src)) {
         srcCache[src] = true
-        mediaDependencies.push(src)
+        imageDependencies.push(src)
       }
 
       /* Change image source attribute to point to the local image */
-      img.setAttribute('src', isWebpCandidateImageMimeType(webp, getMimeType(src)) ? newSrc + '.webp' : newSrc)
+      img.setAttribute('src', newSrc)
 
       /* Remove useless 'resource' attribute */
       img.removeAttribute('resource')
@@ -321,7 +313,7 @@ export abstract class Renderer {
     /* Add lazy loading */
     img.setAttribute('loading', 'lazy')
 
-    return { mediaDependencies }
+    return { imageDependencies }
   }
 
   private shouldKeepImage(dump: Dump, img: DominoElement) {
@@ -334,8 +326,9 @@ export abstract class Renderer {
     )
   }
 
-  protected async treatMedias(parsoidDoc: DominoElement, dump: Dump, articleId: string, webp: boolean) {
-    let mediaDependencies: string[] = []
+  protected async treatMedias(parsoidDoc: DominoElement, dump: Dump, articleId: string) {
+    let imageDependencies: string[] = []
+    let videoDependencies: string[] = []
     let subtitles: string[] = []
     /* Clean/rewrite image tags */
     const imgs = Array.from(parsoidDoc.getElementsByTagName('img'))
@@ -344,14 +337,15 @@ export abstract class Renderer {
 
     for (const videoEl of videos) {
       // <video /> and <audio />
-      const ret = await this.treatVideo(dump, srcCache, articleId, videoEl, webp)
-      mediaDependencies = mediaDependencies.concat(ret.mediaDependencies)
+      const ret = await this.treatVideo(dump, srcCache, articleId, videoEl)
+      imageDependencies = imageDependencies.concat(ret.imageDependencies)
+      videoDependencies = videoDependencies.concat(ret.videoDependencies)
       subtitles = subtitles.concat(ret.subtitles)
     }
 
     for (const imgEl of imgs) {
-      const ret = await this.treatImage(dump, srcCache, articleId, imgEl, webp)
-      mediaDependencies = mediaDependencies.concat(ret.mediaDependencies)
+      const ret = await this.treatImage(dump, srcCache, articleId, imgEl)
+      imageDependencies = imageDependencies.concat(ret.imageDependencies)
     }
 
     /* Improve image frames */
@@ -362,7 +356,7 @@ export abstract class Renderer {
       this.treatImageFrames(dump, parsoidDoc, imageNode)
     }
 
-    return { doc: parsoidDoc, mediaDependencies, subtitles }
+    return { doc: parsoidDoc, imageDependencies, videoDependencies, subtitles }
   }
 
   private isStillLinked(image: DominoElement) {
@@ -394,7 +388,9 @@ export abstract class Renderer {
   }
 
   // TODO: The first part of this method is common for all renders
-  public async processHtml(html: string, dump: Dump, articleId: string, articleDetail: any, _moduleDependencies: any, webp: boolean, callback) {
+  public async processHtml(html: string, dump: Dump, articleId: string, articleDetail: any, _moduleDependencies: any, callback) {
+    let imageDependencies: Array<{ url: string; path: string }> = []
+    let videoDependencies: Array<{ url: string; path: string }> = []
     let mediaDependencies: Array<{ url: string; path: string }> = []
     let subtitles: Array<{ url: string; path: string }> = []
     let doc = domino.createDocument(html)
@@ -411,12 +407,21 @@ export abstract class Renderer {
     )
     doc = this.applyOtherTreatments(doc, dump)
 
-    const tmRet = await this.treatMedias(doc, dump, articleId, webp)
+    const tmRet = await this.treatMedias(doc, dump, articleId)
 
     doc = tmRet.doc
 
-    mediaDependencies = mediaDependencies.concat(
-      tmRet.mediaDependencies
+    videoDependencies = videoDependencies.concat(
+      tmRet.videoDependencies
+        .filter((a) => a)
+        .map((url) => {
+          const path = getMediaBase(url, false)
+          return { url, path }
+        }),
+    )
+
+    imageDependencies = imageDependencies.concat(
+      tmRet.imageDependencies
         .filter((a) => a)
         .map((url) => {
           const path = getMediaBase(url, false)
@@ -463,6 +468,8 @@ export abstract class Renderer {
     return {
       finalHTML,
       mediaDependencies,
+      imageDependencies,
+      videoDependencies,
       subtitles,
     }
   }
diff --git a/src/renderers/rest-api.renderer.ts b/src/renderers/rest-api.renderer.ts
index 3cc9e6bb..67a88397 100644
--- a/src/renderers/rest-api.renderer.ts
+++ b/src/renderers/rest-api.renderer.ts
@@ -34,7 +34,7 @@ export class RestApiRenderer extends DesktopRenderer {
 
   public async render(renderOpts: RenderOpts): Promise<any> {
     const result: RenderOutput = []
-    const { data, articleId, articleDetailXId, webp, _moduleDependencies, isMainPage, dump } = renderOpts
+    const { data, articleId, articleDetailXId, _moduleDependencies, isMainPage, dump } = renderOpts
 
     if (!data) {
       throw new Error(`Cannot render [${data}] into an article`)
@@ -53,13 +53,12 @@ export class RestApiRenderer extends DesktopRenderer {
       if (!isMainPage) {
         dataWithHeader = super.injectH1TitleToHtml(data, articleDetail)
       }
-      const { finalHTML, mediaDependencies, subtitles } = await super.processHtml(
+      const { finalHTML, mediaDependencies, videoDependencies, imageDependencies, subtitles } = await super.processHtml(
         dataWithHeader || data,
         dump,
         articleId,
         articleDetail,
         moduleDependenciesFiltered,
-        webp,
         super.templateDesktopArticle.bind(this),
       )
 
@@ -68,6 +67,8 @@ export class RestApiRenderer extends DesktopRenderer {
         displayTitle: (strippedTitle || articleId.replace(/_/g, ' ')) + (i === 0 ? '' : `/${i}`),
         html: finalHTML,
         mediaDependencies,
+        videoDependencies,
+        imageDependencies,
         moduleDependencies: moduleDependenciesFiltered,
         staticFiles: this.staticFilesListDesktop,
         subtitles,
diff --git a/src/renderers/visual-editor.renderer.ts b/src/renderers/visual-editor.renderer.ts
index 1734f5ec..1330fe24 100644
--- a/src/renderers/visual-editor.renderer.ts
+++ b/src/renderers/visual-editor.renderer.ts
@@ -50,17 +50,16 @@ export class VisualEditorRenderer extends DesktopRenderer {
   public async render(renderOpts: RenderOpts): Promise<any> {
     try {
       const result: RenderOutput = []
-      const { articleId, articleDetail, webp, _moduleDependencies, dump } = renderOpts
+      const { articleId, articleDetail, _moduleDependencies, dump } = renderOpts
       const { html, displayTitle } = await this.retrieveHtml(renderOpts)
       if (html) {
         const moduleDependenciesFiltered = super.filterWikimediaDesktopModules(_moduleDependencies)
-        const { finalHTML, mediaDependencies, subtitles } = await super.processHtml(
+        const { finalHTML, mediaDependencies, videoDependencies, imageDependencies, subtitles } = await super.processHtml(
           html,
           dump,
           articleId,
           articleDetail,
           moduleDependenciesFiltered,
-          webp,
           super.templateDesktopArticle.bind(this),
         )
         result.push({
@@ -68,6 +67,8 @@ export class VisualEditorRenderer extends DesktopRenderer {
           displayTitle,
           html: finalHTML,
           mediaDependencies,
+          videoDependencies,
+          imageDependencies,
           moduleDependencies: moduleDependenciesFiltered,
           staticFiles: this.staticFilesListDesktop,
           subtitles,
diff --git a/src/renderers/wikimedia-mobile.renderer.ts b/src/renderers/wikimedia-mobile.renderer.ts
index ccea36d2..6cbadd1e 100644
--- a/src/renderers/wikimedia-mobile.renderer.ts
+++ b/src/renderers/wikimedia-mobile.renderer.ts
@@ -32,13 +32,15 @@ export class WikimediaMobileRenderer extends MobileRenderer {
   public async render(renderOpts: RenderOpts): Promise<any> {
     try {
       const result: RenderOutput = []
-      const { data, articleId, webp, _moduleDependencies, dump } = renderOpts
+      const { data, articleId, _moduleDependencies, dump } = renderOpts
       const articleDetail = await renderOpts.articleDetailXId.get(articleId)
 
       const displayTitle = this.getStrippedTitle(renderOpts)
       if (data) {
         const moduleDependenciesFiltered = super.filterWikimediaMobileModules(_moduleDependencies)
         let mediaDependenciesVal
+        let videoDependenciesVal
+        let imageDependenciesVal
         let subtitlesVal
         const mobileHTML = domino.createDocument(data)
         const finalHTMLMobile = await this.pipeMobileTransformations(
@@ -48,17 +50,18 @@ export class WikimediaMobileRenderer extends MobileRenderer {
           this.removeHiddenClass,
           this.INTERNAL.unhideSections,
           async (doc) => {
-            const { finalHTML, subtitles, mediaDependencies } = await super.processHtml(
+            const { finalHTML, subtitles, mediaDependencies, videoDependencies, imageDependencies } = await super.processHtml(
               doc.documentElement.outerHTML,
               dump,
               articleId,
               articleDetail,
               moduleDependenciesFiltered,
-              webp,
               super.templateMobileArticle.bind(this),
             )
 
             mediaDependenciesVal = mediaDependencies
+            imageDependenciesVal = imageDependencies
+            videoDependenciesVal = videoDependencies
             subtitlesVal = subtitles
             return domino.createDocument(finalHTML)
           },
@@ -70,6 +73,8 @@ export class WikimediaMobileRenderer extends MobileRenderer {
           displayTitle,
           html: finalHTMLMobile.documentElement.outerHTML,
           mediaDependencies: mediaDependenciesVal,
+          videoDependencies: videoDependenciesVal,
+          imageDependencies: imageDependenciesVal,
           moduleDependencies: moduleDependenciesFiltered,
           staticFiles: this.staticFilesListMobile,
           subtitles: subtitlesVal,
diff --git a/src/types.d.ts b/src/types.d.ts
index 1c747008..b80a4486 100644
--- a/src/types.d.ts
+++ b/src/types.d.ts
@@ -42,6 +42,7 @@ type FileDetail = {
   namespace?: string
   mult?: number
   width?: number
+  kind: string
 }
 
 type ArticleRedirect = {
diff --git a/src/util/articleListMainPage.ts b/src/util/articleListMainPage.ts
index c988aca7..18b10201 100644
--- a/src/util/articleListMainPage.ts
+++ b/src/util/articleListMainPage.ts
@@ -1,14 +1,12 @@
 import { Dump } from '../Dump.js'
-import { encodeArticleIdForZimHtmlUrl, isWebpCandidateImageMimeType, getMimeType } from '../util/index.js'
+import { encodeArticleIdForZimHtmlUrl } from '../util/index.js'
 
 export function makeArticleListItem(dump: Dump, articleEntry: ArticleDetail) {
   return `<li><a href="${encodeArticleIdForZimHtmlUrl(articleEntry.title.replace(/ /g, '_'))}">${articleEntry.title.replace(/_/g, ' ') || ''}<a></li>\n`
 }
 
-export function makeArticleImageTile(dump: Dump, articleEntry: ArticleDetail, webp: boolean) {
+export function makeArticleImageTile(dump: Dump, articleEntry: ArticleDetail) {
   return `<a class="item" href="${encodeArticleIdForZimHtmlUrl(articleEntry.title.replace(/ /g, '_'))}">
-            <figure><img loading="lazy" src="${
-              articleEntry.internalThumbnailUrl + (isWebpCandidateImageMimeType(webp, getMimeType(articleEntry.internalThumbnailUrl)) ? '.webp' : '')
-            }" />
+            <figure><img loading="lazy" src="${articleEntry.internalThumbnailUrl}" />
             <figcaption>${(articleEntry.title || '').replace(/_/g, ' ')}</figcaption></figure></a>\n`
 }
diff --git a/src/util/const.ts b/src/util/const.ts
index 0ec0645a..d232e2db 100644
--- a/src/util/const.ts
+++ b/src/util/const.ts
@@ -3,7 +3,6 @@ export const IMAGE_THUMB_URL_REGEX = /^.*\/[0-9a-fA-F]{1}\/[0-9a-fA-F]{2}\/([^/]
 export const LATEX_IMAGE_URL_REGEX = /^.*\/math\/render\/svg\/([A-Za-z0-9]+)$/
 export const WIKIHIERO_IMAGE_URL_REGEX = /^.*\/wikihiero\/img\/(.*\.png)(\?.*)?$/
 export const FANDOM_IMAGE_URL_REGEX = /([^\/]+)\/revision\//i
-export const IMAGE_URL_REGEX = /(https?:\/\/.*\.(?:jpg|gif|png|svg|jpeg)(\?.*)?)/i
 export const MIN_IMAGE_THRESHOLD_ARTICLELIST_PAGE = 10
 export const CONCURRENCY_LIMIT = 10
 export const IMAGE_MIME_REGEX = /^image+[/-\w.]+$/
diff --git a/src/util/dump.ts b/src/util/dump.ts
index 0a396318..999dcef0 100644
--- a/src/util/dump.ts
+++ b/src/util/dump.ts
@@ -32,7 +32,7 @@ export async function getAndProcessStylesheets(downloader: Downloader, links: Ar
         const cssUrlRegexp = new RegExp('url\\([\'"]{0,1}(.+?)[\'"]{0,1}\\)', 'gi')
 
         logger.info(`Downloading CSS from ${decodeURI(cssUrl)}`)
-        const { content } = await downloader.downloadContent(cssUrl)
+        const { content } = await downloader.downloadContent(cssUrl, 'css')
         const body = content.toString()
 
         let rewrittenCss = `\n/* start ${cssUrl} */\n\n`
@@ -63,7 +63,7 @@ export async function getAndProcessStylesheets(downloader: Downloader, links: Ar
               /* Download CSS dependency, but avoid duplicate calls */
               if (!downloader.cssDependenceUrls.hasOwnProperty(url) && filename) {
                 downloader.cssDependenceUrls[url] = true
-                filesToDownloadXPath.set(config.output.dirs.mediawiki + '/' + filename, { url: urlHelper.serializeUrl(url), namespace: '-' })
+                filesToDownloadXPath.set(config.output.dirs.mediawiki + '/' + filename, { url: urlHelper.serializeUrl(url), namespace: '-', kind: 'media' })
               }
             } else {
               logger.warn(`Skipping CSS [url(${url})] because the pathname could not be found [${filePathname}]`)
@@ -132,7 +132,7 @@ export async function downloadAndSaveModule(zimCreator: ZimCreator, downloader:
 
   logger.info(`Getting [${type}] module [${moduleApiUrl}]`)
 
-  const { content } = await downloader.downloadContent(moduleApiUrl)
+  const { content } = await downloader.downloadContent(moduleApiUrl, 'module')
   let text = content.toString()
 
   if (type === 'js') {
diff --git a/src/util/misc.ts b/src/util/misc.ts
index 70f907a7..7f2ccd80 100644
--- a/src/util/misc.ts
+++ b/src/util/misc.ts
@@ -4,7 +4,6 @@ import { defaultStreamRequestOptions } from '../Downloader.js'
 import countryLanguage from '@ladjs/country-language'
 import fs from 'fs'
 import path from 'path'
-import mime from 'mime-types'
 import mkdirp from 'mkdirp'
 import os from 'os'
 import pathParser from 'path'
@@ -17,7 +16,6 @@ import {
   WIKIHIERO_IMAGE_URL_REGEX,
   IMAGE_THUMB_URL_REGEX,
   FIND_HTTP_REGEX,
-  IMAGE_URL_REGEX,
   BITMAP_IMAGE_MIME_REGEX,
   IMAGE_MIME_REGEX,
   WEBP_CANDIDATE_IMAGE_MIME_TYPE,
@@ -370,10 +368,6 @@ export function stripHttpFromUrl(url: string): string {
   return url.replace(FIND_HTTP_REGEX, '')
 }
 
-export function isImageUrl(url: string): boolean {
-  return IMAGE_URL_REGEX.test(url)
-}
-
 export function isImageMimeType(mimeType: string): boolean {
   return IMAGE_MIME_REGEX.test(mimeType)
 }
@@ -382,55 +376,8 @@ export function isBitmapImageMimeType(mimeType: string): boolean {
   return BITMAP_IMAGE_MIME_REGEX.test(mimeType)
 }
 
-export function isWebpCandidateImageMimeType(webp: boolean, content_type: string) {
-  return webp && WEBP_CANDIDATE_IMAGE_MIME_TYPE.test(content_type)
-}
-
-/*
- * Get best fitting MIME type from contentType or pathname
- * Preference:
- *   1. content-type if one of preferedDiscreteTypes
- *   2. mime-type from extension if in preferedDiscreteTypes
- *   3. any other content-type
- *   4. any other mime-type from extension
- *   5. null
- */
-export function getMimeType(url: string, contentType?: string): string {
-  const preferedDiscreteTypes = ['image', 'audio', 'video']
-
-  let cMimeType: string
-  if (contentType) {
-    // i.e. "application/json; charset=utf-8"
-    cMimeType = contentType.indexOf(';') === -1 ? contentType : contentType.slice(0, contentType.indexOf(';'))
-    cMimeType = cMimeType.trim()
-
-    const discreteType = cMimeType.slice(0, cMimeType.indexOf('/'))
-    if (preferedDiscreteTypes.includes(discreteType)) {
-      return cMimeType
-    }
-  }
-
-  let pMimeType: string
-  if (url) {
-    // provide a bas url for parsing relative paths
-    let { pathname } = new URL(url, 'http://large.com/path/to/strip/here')
-
-    // Fandom has an URL scheme that attaches /revision/... to the path
-    const parts = FANDOM_IMAGE_URL_REGEX.exec(pathname)
-    if (parts !== null) {
-      pathname = parts[1]
-    }
-
-    pMimeType = mime.lookup(pathname)
-    if (pMimeType) {
-      const discreteType = pMimeType.slice(0, pMimeType.indexOf('/'))
-      if (preferedDiscreteTypes.includes(discreteType)) {
-        return pMimeType
-      }
-    }
-  }
-
-  return cMimeType || pMimeType || null
+export function isWebpCandidateImageMimeType(content_type: string) {
+  return WEBP_CANDIDATE_IMAGE_MIME_TYPE.test(content_type)
 }
 
 export function cleanupAxiosError(err: AxiosError) {
diff --git a/src/util/saveArticles.ts b/src/util/saveArticles.ts
index 911cbb2b..57389463 100644
--- a/src/util/saveArticles.ts
+++ b/src/util/saveArticles.ts
@@ -29,20 +29,20 @@ export async function downloadFiles(fileStore: RKVS<FileDetail>, retryStore: RKV
 
     // todo align fileDownloadPairs and listOfArguments
     const listOfArguments = []
-    for (const [path, { url, namespace, mult, width }] of Object.entries(fileDownloadPairs)) {
-      listOfArguments.push({ path, url, namespace, mult, width })
+    for (const [path, { url, namespace, mult, width, kind }] of Object.entries(fileDownloadPairs)) {
+      listOfArguments.push({ path, url, namespace, mult, width, kind })
     }
 
     const responses = await downloadBulk(listOfArguments, downloader)
     for (const resp of responses) {
       let isFailed = false
       try {
-        if (resp.result && resp.result.content) {
+        if (resp.result && resp.result.content && resp.result.contentType) {
           const article = new ZimArticle({
             url: resp.path,
             data: resp.result.content,
             ns: resp.namespace || 'I',
-            mimeType: resp.result.responseHeaders['content-type'],
+            mimeType: resp.result.contentType,
           })
           zimCreator.addArticle(article)
           dump.status.files.success += 1
@@ -54,7 +54,7 @@ export async function downloadFiles(fileStore: RKVS<FileDetail>, retryStore: RKV
       } finally {
         if (isFailed) {
           if (doRetry && resp.status !== 404) {
-            await retryStore.set(resp.path, { url: resp.url, namespace: resp.namespace, mult: resp.mult, width: resp.width })
+            await retryStore.set(resp.path, { url: resp.url, namespace: resp.namespace, mult: resp.mult, width: resp.width, kind: resp.kind })
           } else {
             logger.warn(`Error downloading file [${urlHelper.deserializeUrl(resp.url)}], skipping`)
             dump.status.files.fail += 1
@@ -105,12 +105,12 @@ async function downloadBulk(listOfArguments: any[], downloader: Downloader): Pro
         resp.namespace = arg.val.namespace
         resp.mult = arg.val.mult
         resp.width = arg.val.width
+        resp.kind = arg.val.kind
 
         return downloader
-          .downloadContent(arg.val.url, false)
+          .downloadContent(arg.val.url, arg.val.kind, false)
           .then((r) => {
             resp.result = r
-            resp.path += resp.result.responseHeaders.path_postfix || ''
             return resp
           })
           .catch((err) => {
@@ -174,6 +174,8 @@ async function saveArticle(
   zimCreator: ZimCreator,
   finalHTML: string,
   mediaDependencies: any,
+  imageDependencies: any,
+  videoDependencies: any,
   subtitles: any,
   articleId: string,
   articleTitle: string,
@@ -184,7 +186,7 @@ async function saveArticle(
 
     if (subtitles?.length > 0) {
       subtitles.forEach((s) => {
-        filesToDownload[s.path] = { url: s.url, namespace: '-' }
+        filesToDownload[s.path] = { url: s.url, namespace: '-', kind: 'subtitle' }
       })
     }
 
@@ -198,6 +200,43 @@ async function saveArticle(
         if (currentDepIsHigherRes) {
           filesToDownload[dep.path] = {
             url: urlHelper.serializeUrl(dep.url),
+            kind: 'media',
+            mult,
+            width,
+          }
+        }
+      }
+    }
+
+    if (imageDependencies && imageDependencies.length) {
+      const existingVals = await RedisStore.filesToDownloadXPath.getMany(imageDependencies.map((dep) => dep.path))
+
+      for (const dep of imageDependencies) {
+        const { mult, width } = getSizeFromUrl(dep.url)
+        const existingVal = existingVals[dep.path]
+        const currentDepIsHigherRes = !existingVal || existingVal.width < (width || 10e6) || existingVal.mult < (mult || 1)
+        if (currentDepIsHigherRes) {
+          filesToDownload[dep.path] = {
+            url: urlHelper.serializeUrl(dep.url),
+            kind: 'image',
+            mult,
+            width,
+          }
+        }
+      }
+    }
+
+    if (videoDependencies && videoDependencies.length) {
+      const existingVals = await RedisStore.filesToDownloadXPath.getMany(videoDependencies.map((dep) => dep.path))
+
+      for (const dep of videoDependencies) {
+        const { mult, width } = getSizeFromUrl(dep.url)
+        const existingVal = existingVals[dep.path]
+        const currentDepIsHigherRes = !existingVal || existingVal.width < (width || 10e6) || existingVal.mult < (mult || 1)
+        if (currentDepIsHigherRes) {
+          filesToDownload[dep.path] = {
+            url: urlHelper.serializeUrl(dep.url),
+            kind: 'video',
             mult,
             width,
           }
@@ -298,7 +337,17 @@ export async function saveArticles(zimCreator: ZimCreator, downloader: Downloade
 
           rets = await downloader.getArticle(downloader.webp, _moduleDependencies, articleId, articleDetailXId, renderer, articleUrl, dump, articleDetail, isMainPage)
 
-          for (const { articleId, displayTitle: articleTitle, html: finalHTML, mediaDependencies, moduleDependencies, staticFiles, subtitles } of rets) {
+          for (const {
+            articleId,
+            displayTitle: articleTitle,
+            html: finalHTML,
+            mediaDependencies,
+            imageDependencies,
+            videoDependencies,
+            moduleDependencies,
+            staticFiles,
+            subtitles,
+          } of rets) {
             if (!finalHTML) {
               logger.warn(`No HTML returned for article [${articleId}], skipping`)
               continue
@@ -324,7 +373,10 @@ export async function saveArticles(zimCreator: ZimCreator, downloader: Downloade
              * To parse and download simultaniously, we don't await on save,
              * but instead cache the promise in a queue and check it later
              */
-            promises.push([articleId, saveArticle(zimCreator, finalHTML, mediaDependencies, subtitles, articleId, articleTitle, articleDetail)])
+            promises.push([
+              articleId,
+              saveArticle(zimCreator, finalHTML, mediaDependencies, imageDependencies, videoDependencies, subtitles, articleId, articleTitle, articleDetail),
+            ])
           }
         } catch (err) {
           dump.status.articles.fail += 1
diff --git a/test/unit/downloader.test.ts b/test/unit/downloader.test.ts
index 4dfc34ce..fa657aa1 100644
--- a/test/unit/downloader.test.ts
+++ b/test/unit/downloader.test.ts
@@ -3,7 +3,7 @@ import Downloader from '../../src/Downloader.js'
 import MediaWiki from '../../src/MediaWiki.js'
 import RedisStore from '../../src/RedisStore.js'
 import Axios from 'axios'
-import { mwRetToArticleDetail, stripHttpFromUrl, isImageUrl } from '../../src/util/index.js'
+import { mwRetToArticleDetail, stripHttpFromUrl } from '../../src/util/index.js'
 import S3 from '../../src/S3.js'
 import { Dump } from '../../src/Dump.js'
 import { config } from '../../src/config.js'
@@ -71,18 +71,18 @@ describe('Downloader class', () => {
   })
 
   test('downloader.downloadContent returns', async () => {
-    const contentRes = await downloader.downloadContent('https://upload.wikimedia.org/wikipedia/commons/thumb/c/cd/London_Montage_L.jpg/275px-London_Montage_L.jpg')
-    expect(contentRes.responseHeaders).toBeDefined()
+    const contentRes = await downloader.downloadContent('https://upload.wikimedia.org/wikipedia/commons/thumb/c/cd/London_Montage_L.jpg/275px-London_Montage_L.jpg', 'image')
+    expect(contentRes.contentType).toBeDefined()
   })
 
   test('Webp compression working for cmyk color-space images', async () => {
-    const { content } = await downloader.downloadContent('https://upload.wikimedia.org/wikipedia/commons/thumb/5/5a/LOGO_HAEMMERLIN.jpg/550px-LOGO_HAEMMERLIN.jpg')
+    const { content } = await downloader.downloadContent('https://upload.wikimedia.org/wikipedia/commons/thumb/5/5a/LOGO_HAEMMERLIN.jpg/550px-LOGO_HAEMMERLIN.jpg', 'image')
     const fileType = await FileType.fileTypeFromBuffer(Buffer.from(content))
     expect(fileType?.mime).toEqual('image/webp')
   })
 
   test('downloader.downloadContent throws on non-existant url', async () => {
-    await expect(downloader.downloadContent('https://upload.wikimedia.org/wikipedia/commons/thumb/c/cd/thisdoesnotexist.jpg')).rejects.toThrowError(
+    await expect(downloader.downloadContent('https://upload.wikimedia.org/wikipedia/commons/thumb/c/cd/thisdoesnotexist.jpg', 'image')).rejects.toThrowError(
       new Error('Request failed with status code 404'),
     )
   })
@@ -110,7 +110,7 @@ describe('Downloader class', () => {
   })
 
   test('downloadContent throws when empty string is passed', async () => {
-    await expect(downloader.downloadContent('')).rejects.toThrowError()
+    await expect(downloader.downloadContent('', 'image')).rejects.toThrowError()
   })
 
   test('downloadContent successfully downloaded an image', async () => {
@@ -122,8 +122,8 @@ describe('Downloader class', () => {
       imgToGetSrc = imgToGet.getAttribute('src')
     }
     // This is the downloading of an image
-    const LondonImage = await downloader.downloadContent(imgToGetSrc)
-    expect(LondonImage.responseHeaders['content-type']).toMatch(/image\//i)
+    const LondonImage = await downloader.downloadContent(imgToGetSrc, 'image')
+    expect(LondonImage.contentType).toMatch(/image\//i)
   })
 
   test('downloadContent successfully downloads a map image', async () => {
@@ -135,8 +135,8 @@ describe('Downloader class', () => {
       imgToGetSrc = imgToGet.getAttribute('src')
     }
     // This is the downloading of an image
-    const LondonImage = await downloader.downloadContent(imgToGetSrc)
-    expect(LondonImage.responseHeaders['content-type']).toMatch(/image\//i)
+    const LondonImage = await downloader.downloadContent(imgToGetSrc, 'image')
+    expect(LondonImage.contentType).toMatch(/image\//i)
   })
 
   describe('getArticle method', () => {
@@ -278,58 +278,6 @@ describe('Downloader class', () => {
     }
   })
 
-  describe('isImageUrl method', () => {
-    test('Checked Image type: png', async () => {
-      const isPngFile = isImageUrl('https://bm.wikipedia.org/static/images/project-logos/bmwiki-2x.svg.png')
-      expect(isPngFile).toBeTruthy()
-    })
-
-    test('Checked Image type: jpg', async () => {
-      const isJpgFile = isImageUrl('https://bm.wikipedia.org/static/images/project-logos/bmwiki-2x.JPG')
-      expect(isJpgFile).toBeTruthy()
-    })
-
-    test('Checked Image type: svg', async () => {
-      const isSvgFile = isImageUrl('https://bm.wikipedia.org/static/images/project-logos/bmwiki-2x.svg')
-      expect(isSvgFile).toBeTruthy()
-    })
-
-    test('Checked Image type: jpeg', async () => {
-      const isJpegFile = isImageUrl('https://bm.wikipedia.org/static/images/project-logos/bmwiki-2x.JPEG')
-      expect(isJpegFile).toBeTruthy()
-    })
-
-    test('Checked Image type: gif', async () => {
-      const isgifFile = isImageUrl('https://bm.wikipedia.org/static/images/project-logos/bmwiki-2x.gif')
-      expect(isgifFile).toBeTruthy()
-    })
-
-    test('Checked Image URL with arguments', async () => {
-      const isgifFileWithArgs = isImageUrl('https://bm.wikipedia.org/static/images/project-logos/bmwiki-2x.gif?foo=bar')
-      expect(isgifFileWithArgs).toBeTruthy()
-    })
-
-    test('Url is not image type', async () => {
-      const isnotImage = isImageUrl('https://en.wikipedia.org/w/api.php?action=query&meta=siteinfo&format=json&formatversion=2')
-      expect(isnotImage).not.toBeTruthy()
-    })
-
-    test('Url is empty string', async () => {
-      const isEmptyString = isImageUrl('')
-      expect(isEmptyString).not.toBeTruthy()
-    })
-
-    test('Image Url has no extension', async () => {
-      const imageHasNoExtension = isImageUrl('https://bm.wikipedia.org/static/images/project-logos/bmwiki-2x')
-      expect(imageHasNoExtension).not.toBeTruthy()
-    })
-
-    test('Image Url extension is undefined', async () => {
-      const extensionIsUndefined = isImageUrl('https://bm.wikipedia.org/static/images/project-logos/undefined')
-      expect(extensionIsUndefined).not.toBeTruthy()
-    })
-  })
-
   const describeIf = process.env.S3_URL ? describe : describe.skip
 
   describeIf('Downloader class with optimisation', () => {
@@ -358,11 +306,6 @@ describe('Downloader class', () => {
       await s3.initialise()
     })
 
-    test('Etag Not Present', async () => {
-      const etagNotPresent = await downloader.downloadContent('https://en.wikipedia.org/w/extensions/WikimediaBadges/resources/images/badge-silver-star.png?70a8c')
-      expect(etagNotPresent.responseHeaders.etag).toBeUndefined()
-    })
-
     test('Delete image from S3', async () => {
       const testImage = 'https://bm.wikipedia.org/static/images/project-logos/bmwiki-2x.png'
 
@@ -385,7 +328,7 @@ describe('Downloader class', () => {
       await s3.deleteBlob({ Bucket: s3UrlObj.query.bucketName as string, Key: imagePath })
 
       // Download the image (and cache it in S3)
-      await downloader.downloadContent(randomImage)
+      await downloader.downloadContent(randomImage, 'image')
 
       // Async downloadContent(), waiting this is done
       await setTimeout(5000)
@@ -394,18 +337,15 @@ describe('Downloader class', () => {
       const upstreamResp = await Axios(randomImage)
       const s3Resp = await s3.downloadBlob(imagePath)
       expect(downloader.removeEtagWeakPrefix(`${upstreamResp.headers.etag}`)).toEqual(s3Resp.Metadata.etag)
-      expect(upstreamResp.headers['content-type']).toEqual(s3Resp.Metadata.contenttype)
 
       // Overwrite Image with new Etag to S3
       const newEtag = '686897696a7c876b7e'
-      const newContentType = 'application/octet-stream'
-      await s3.uploadBlob(imagePath, upstreamResp.data, newEtag, newContentType, '1')
+      await s3.uploadBlob(imagePath, upstreamResp.data, newEtag, '1')
       await setTimeout(10000)
 
       // Download again to check the Etag has been overwritten properly
       const newS3Resp = await s3.downloadBlob(imagePath)
       expect(newS3Resp.Metadata.etag).toEqual(newEtag)
-      expect(newS3Resp.Metadata.contenttype).toEqual(newContentType)
 
       // Remove Image after test
       await s3.deleteBlob({ Bucket: s3UrlObj.query.bucketName as string, Key: imagePath })
@@ -416,7 +356,6 @@ describe('Downloader class', () => {
     const resp = await Axios(
       'https://commons.wikimedia.org/w/api.php?action=query&generator=random&grnnamespace=6&prop=imageinfo&iiprop=url&formatversion=2&iiurlwidth=100&format=json&formatversion=2',
     )
-    const url = resp.data.query.pages[0].imageinfo[0].url
-    return isImageUrl(url) ? url : getRandomImageUrl()
+    return resp.data.query.pages[0].imageinfo[0].url
   }
 })
diff --git a/test/unit/s3.test.ts b/test/unit/s3.test.ts
index cfa0cfce..593065b9 100644
--- a/test/unit/s3.test.ts
+++ b/test/unit/s3.test.ts
@@ -29,7 +29,7 @@ describeIf('S3', () => {
 
     const s3TestKey = `bm.wikipedia.org/static/images/project-logos/${Math.random().toString(36).slice(2, 7)}.png`
     // Image uploaded to S3
-    await s3.uploadBlob(s3TestKey, '42', '42', 'image/png', '1')
+    await s3.uploadBlob(s3TestKey, '42', '42', '1')
 
     const imageExist = await s3.downloadBlob(s3TestKey)
     // Image exists in S3
diff --git a/test/unit/treatments/media.treatment.test.ts b/test/unit/treatments/media.treatment.test.ts
index bc6eb5d4..fced0472 100644
--- a/test/unit/treatments/media.treatment.test.ts
+++ b/test/unit/treatments/media.treatment.test.ts
@@ -9,14 +9,14 @@ describe('MediaTreatment', () => {
     public render(): any {
       return null
     }
-    public async testTreatVideo(dump: Dump, srcCache: KVS<boolean>, articleId: string, videoEl: DominoElement, webp: boolean) {
-      return this.treatVideo(dump, srcCache, articleId, videoEl, webp)
+    public async testTreatVideo(dump: Dump, srcCache: KVS<boolean>, articleId: string, videoEl: DominoElement) {
+      return this.treatVideo(dump, srcCache, articleId, videoEl)
     }
     public async testTreatSubtitle(trackEle: DominoElement, articleId: string) {
       return this.treatSubtitle(trackEle, articleId)
     }
-    public async testTreatMedias(parsoidDoc: DominoElement, dump: Dump, articleId: string, webp: boolean) {
-      return this.treatMedias(parsoidDoc, dump, articleId, webp)
+    public async testTreatMedias(parsoidDoc: DominoElement, dump: Dump, articleId: string) {
+      return this.treatMedias(parsoidDoc, dump, articleId)
     }
   }
 
@@ -54,7 +54,7 @@ describe('MediaTreatment', () => {
       const htmlStr = await convertWikicodeToHtml(wikicode, dump.mwMetaData.baseUrl)
 
       const htmlDoc = domino.createDocument(htmlStr.data)
-      const contentRes = await testableRenderer.testTreatVideo(dump, {}, 'User:Charliechlorine/sandbox', htmlDoc.querySelector('video'), false)
+      const contentRes = await testableRenderer.testTreatVideo(dump, {}, 'User:Charliechlorine/sandbox', htmlDoc.querySelector('video'))
       // Converted wikicode to HTML for multiple subtitle
       testHtmlRewritingE2e(wikicode, htmlStr.data)
       // Video multiple subtitles rewriting matches
@@ -90,9 +90,10 @@ describe('MediaTreatment', () => {
         <track kind="subtitles" type="text/x-srt" src="//commons.wikimedia.org/w/api.php?action=timedtext&amp;title=File%3AGout.webm&amp;lang=ar&amp;trackformat=srt&amp;origin=%2A" srclang="ar" label="العربية (ar)" data-mwtitle="" data-dir="rtl">
         <track kind="subtitles" type="text/vtt" src="//commons.wikimedia.org/w/api.php?action=timedtext&amp;title=File%3AGout.webm&amp;lang=ar&amp;trackformat=vtt&amp;origin=%2A" srclang="ar" label="العربية (ar)" data-mwtitle="" data-dir="rtl"></video>`
       let htmlDoc = domino.createDocument(htmlStr)
-      let ret = await testableRenderer.testTreatVideo(dump, {}, 'Gout', htmlDoc.querySelector('video'), false)
+      let ret = await testableRenderer.testTreatVideo(dump, {}, 'Gout', htmlDoc.querySelector('video'))
       // Correct video resolution for width greater than videoEl
-      expect(ret.mediaDependencies[1]).toEqual('https://upload.wikimedia.org/wikipedia/commons/transcoded/3/3d/Gout.webm/Gout.webm.180p.vp9.webm')
+      expect(ret.videoDependencies).toEqual(['https://upload.wikimedia.org/wikipedia/commons/transcoded/3/3d/Gout.webm/Gout.webm.180p.vp9.webm'])
+      expect(ret.imageDependencies).toEqual(['https://upload.wikimedia.org/wikipedia/commons/thumb/3/3d/Gout.webm/300px--Gout.webm.jpg'])
 
       htmlStr = `<video poster="https://upload.wikimedia.org/wikipedia/commons/thumb/3/3d/Gout.webm/300px--Gout.webm.jpg" controls="" preload="none" height="169" width="800" resource="./File:Gout.webm">
     <source src="//upload.wikimedia.org/wikipedia/commons/3/3d/Gout.webm" type="video/webm; codecs=&quot;vp9, vorbis&quot;" data-file-width="700" data-file-height="1080" data-title="Original WebM file, 1,920 × 1,080 (735 kbps)" data-shorttitle="WebM source">
@@ -102,16 +103,18 @@ describe('MediaTreatment', () => {
     <track kind="subtitles" type="text/x-srt" src="//commons.wikimedia.org/w/api.php?action=timedtext&amp;title=File%3AGout.webm&amp;lang=ar&amp;trackformat=srt&amp;origin=%2A" srclang="ar" label="العربية (ar)" data-mwtitle="" data-dir="rtl">
     <track kind="subtitles" type="text/vtt" src="//commons.wikimedia.org/w/api.php?action=timedtext&amp;title=File%3AGout.webm&amp;lang=ar&amp;trackformat=vtt&amp;origin=%2A" srclang="ar" label="العربية (ar)" data-mwtitle="" data-dir="rtl"></video>`
       htmlDoc = domino.createDocument(htmlStr)
-      ret = await testableRenderer.testTreatVideo(dump, {}, 'Gout', htmlDoc.querySelector('video'), false)
+      ret = await testableRenderer.testTreatVideo(dump, {}, 'Gout', htmlDoc.querySelector('video'))
       // Correct video resolution for all widths less than videoEl
-      expect(ret.mediaDependencies[1]).toEqual('https://upload.wikimedia.org/wikipedia/commons/transcoded/3/3d/Gout.webm/Gout.webm.780p.webm')
+      expect(ret.videoDependencies).toEqual(['https://upload.wikimedia.org/wikipedia/commons/transcoded/3/3d/Gout.webm/Gout.webm.780p.webm'])
+      expect(ret.imageDependencies).toEqual(['https://upload.wikimedia.org/wikipedia/commons/thumb/3/3d/Gout.webm/300px--Gout.webm.jpg'])
 
       htmlStr = `<video poster="//upload.wikimedia.org/wikipedia/commons/thumb/2/23/Apollo_13_Houston%2C_We%27ve_Got_a_Problem.ogv/220px--Apollo_13_Houston%2C_We%27ve_Got_a_Problem.ogv.jpg" preload="none" height="165" width="220" resource="./File:Apollo_13_Houston,_We've_Got_a_Problem.ogv" controls="40">
     <source src="//upload.wikimedia.org/wikipedia/commons/2/23/Apollo_13_Houston%2C_We%27ve_Got_a_Problem.ogv" type="video/ogg; codecs=&quot;theora, vorbis&quot;" data-file-width="400" data-file-height="300" data-title="Original Ogg file, 400 × 300 (616 kbps)" data-shorttitle="Ogg source"></video>`
       htmlDoc = domino.createDocument(htmlStr)
-      ret = await testableRenderer.testTreatVideo(dump, {}, 'Appolo_13', htmlDoc.querySelector('video'), false)
+      ret = await testableRenderer.testTreatVideo(dump, {}, 'Appolo_13', htmlDoc.querySelector('video'))
       // Remove video if no appropriate video/audio source
-      expect(ret.mediaDependencies).toHaveLength(0)
+      expect(ret.videoDependencies).toHaveLength(0)
+      expect(ret.imageDependencies).toHaveLength(0)
     })
 
     test('Ogg audio retrival', async () => {
@@ -121,9 +124,10 @@ describe('MediaTreatment', () => {
         <source src="//upload.wikimedia.org/wikipedia/commons/transcoded/a/a1/William_Shakespeare_%28Spoken_Article%29.ogg/William_Shakespeare_%28Spoken_Article%29.ogg.mp3" type="audio/mpeg" data-title="MP3" data-shorttitle="MP3">
         </audio>`
       const htmlDoc = domino.createDocument(htmlStr)
-      const ret = await testableRenderer.testTreatVideo(dump, {}, 'Michael_Jackson', htmlDoc.querySelector('audio'), false)
+      const ret = await testableRenderer.testTreatVideo(dump, {}, 'Michael_Jackson', htmlDoc.querySelector('audio'))
       // Correct audio file
-      expect(ret.mediaDependencies[0]).toEqual('https://upload.wikimedia.org/wikipedia/commons/a/a1/William_Shakespeare_%28Spoken_Article%29.ogg')
+      expect(ret.videoDependencies).toEqual(['https://upload.wikimedia.org/wikipedia/commons/a/a1/William_Shakespeare_%28Spoken_Article%29.ogg'])
+      expect(ret.imageDependencies).toHaveLength(0)
     })
   })
 
@@ -132,11 +136,18 @@ describe('MediaTreatment', () => {
     afterAll(stopRedis)
 
     test('treatMedias format=""', async () => {
-      const { downloader, dump } = await setupScrapeClasses({ format: '' }) // en wikipedia
+      const { dump } = await setupScrapeClasses({ format: '' }) // en wikipedia
 
       const doc = domino.createDocument(html)
 
-      const ret = await testableRenderer.testTreatMedias(doc, dump, 'Dendritic_cell', downloader.webp)
+      const ret = await testableRenderer.testTreatMedias(doc, dump, 'Dendritic_cell')
+      expect(ret.imageDependencies).toEqual([
+        'https://upload.wikimedia.org/wikipedia/commons/thumb/b/b7/S6-Dendritic_Cells_with_Conidia_in_Collagen.ogv/120px--S6-Dendritic_Cells_with_Conidia_in_Collagen.ogv.jpg',
+        'https://upload.wikimedia.org/wikipedia/commons/thumb/f/fa/Dendritic_cell_revealed.jpg/250px-Dendritic_cell_revealed.jpg',
+      ])
+      expect(ret.videoDependencies).toEqual([
+        'https://upload.wikimedia.org/wikipedia/commons/transcoded/b/b7/S6-Dendritic_Cells_with_Conidia_in_Collagen.ogv/S6-Dendritic_Cells_with_Conidia_in_Collagen.ogv.120p.vp9.webm',
+      ])
 
       const videoEl = ret.doc.querySelector('video')
       const videoPosterUrl = videoEl.getAttribute('poster')
@@ -156,11 +167,11 @@ describe('MediaTreatment', () => {
     })
 
     test('treatMedias format="nopic"', async () => {
-      const { downloader, dump } = await setupScrapeClasses({ format: 'nopic' }) // en wikipedia
+      const { dump } = await setupScrapeClasses({ format: 'nopic' }) // en wikipedia
 
       const doc = domino.createDocument(html)
 
-      const ret = await testableRenderer.testTreatMedias(doc, dump, 'Dendritic_cell', downloader.webp)
+      const ret = await testableRenderer.testTreatMedias(doc, dump, 'Dendritic_cell')
 
       const videoEl = ret.doc.querySelector('video')
       const imgEl = ret.doc.querySelector('img')
@@ -172,11 +183,11 @@ describe('MediaTreatment', () => {
     })
 
     test('treatMedias format="novid"', async () => {
-      const { downloader, dump } = await setupScrapeClasses({ format: 'novid' }) // en wikipedia
+      const { dump } = await setupScrapeClasses({ format: 'novid' }) // en wikipedia
 
       const doc = domino.createDocument(html)
 
-      const ret = await testableRenderer.testTreatMedias(doc, dump, 'Dendritic_cell', downloader.webp)
+      const ret = await testableRenderer.testTreatMedias(doc, dump, 'Dendritic_cell')
 
       const videoEl = ret.doc.querySelector('video')
       const imgEl = ret.doc.querySelector('img')
diff --git a/test/unit/util.test.ts b/test/unit/util.test.ts
index 4789507b..705df9b5 100644
--- a/test/unit/util.test.ts
+++ b/test/unit/util.test.ts
@@ -8,7 +8,6 @@ import {
   getFullUrl,
   getMediaBase,
   normalizeMwResponse,
-  getMimeType,
   isWebpCandidateImageMimeType,
   cleanupAxiosError,
   extractArticleList,
@@ -215,100 +214,13 @@ describe('Utils', () => {
     ).toEqual('589fd4e3821c15d4fcebcedf2effd5b0.png')
   })
 
-  test('MIME Type parsing from content-type and url', async () => {
-    // upper-case url, no content-type
-    let mimeType = getMimeType('https://upload.wikimedia.org/wikipedia/commons/thumb/9/99/Peloneustes_philarchus_Tubingen.JPG/250px-Peloneustes_philarchus_Tubingen.JPG')
-    expect(mimeType).toEqual('image/jpeg')
-    // conflicting types -> prefer content-type
-    mimeType = getMimeType('https://upload.wikimedia.org/wikipedia/commons/thumb/9/99/Peloneustes_philarchus_Tubingen.JPG/250px-Peloneustes_philarchus_Tubingen.JPG', 'video/mp4')
-    expect(mimeType).toEqual('video/mp4')
-    // invalid url, no content-type
-    mimeType = getMimeType('http://example.com')
-    expect(mimeType).toEqual(null)
-    // fandom url
-    mimeType = getMimeType('https://static.wikia.nocookie.net/minecraft_gamepedia/images/f/fc/Monolith_small.png/revision/latest/scale-to-width-down/250?cb=20191227051944')
-    expect(mimeType).toEqual('image/png')
-    // content-type with charset and space on weird position, url without extension
-    mimeType = getMimeType('https://en.wikipedia.org/wiki/Peloneustes', 'text/plain ; charset=UTF-8')
-    expect(mimeType).toEqual('text/plain')
-    // content-type none-prefered type, but url is
-    mimeType = getMimeType(
-      'https://upload.wikimedia.org/wikipedia/commons/thumb/3/39/Peloneustes_Skeletal_Mount_from_Andrews_%281910%29.png/357px-Peloneustes_Skeletal_Mount_from_Andrews_%281910%29.png',
-      'application/octet-stream',
-    )
-    expect(mimeType).toEqual('image/png')
-    // both none-prefered but conflicting types
-    mimeType = getMimeType('https://script.wikia.nocookie.net/fandom-ae-assets/platforms/v127.0.0/ucp-desktop/main.bundle.js', 'text/html')
-    expect(mimeType).toEqual('text/html')
-    // with query
-    mimeType = getMimeType('http://esample.com/test.svg?asdfa=asfas&328=x')
-    expect(mimeType).toEqual('image/svg+xml')
-  })
-
-  test('isWebpCandidate by image Url mime type', async () => {
-    const isWebpCandidateImageUrl = (url) => {
-      return isWebpCandidateImageMimeType(true, getMimeType(url))
-    }
-    // Thumbs
-    // Thumb 1
-    expect(isWebpCandidateImageUrl('https://upload.wikimedia.org/wikipedia/commons/thumb/3/39/Westminstpalace.jpg/220px-Westminstpalace.jpg')).toBeTruthy()
-    // No thumb'
-    expect(isWebpCandidateImageUrl('https://upload.wikimedia.org/wikipedia/commons/3/39/Westminstpalace.jpg')).toBeTruthy()
-    // SVG
-    expect(isWebpCandidateImageUrl('https://upload.wikimedia.org/wikipedia/commons/0/0d/VFPt_Solenoid_correct2.svg')).toBeFalsy()
-    // SVG PNG thumb
-    expect(isWebpCandidateImageUrl('https://upload.wikimedia.org/wikipedia/commons/thumb/0/0d/VFPt_Solenoid_correct2.svg/120px-VFPt_Solenoid_correct2.svg.png')).toBeTruthy()
-    // Video poster
-    expect(
-      isWebpCandidateImageUrl(
-        'https://upload.wikimedia.org/wikipedia/commons/thumb/b/b7/S6-Dendritic_Cells_with_Conidia_in_Collagen.ogv/120px--S6-Dendritic_Cells_with_Conidia_in_Collagen.ogv.jpg',
-      ),
-    ).toBeTruthy()
-    // OGG file
-    expect(isWebpCandidateImageUrl('https://upload.wikimedia.org/wikipedia/commons/c/c6/De-Z%C3%BCrich.ogg')).toBeFalsy()
-    // Long thumb
-    expect(
-      isWebpCandidateImageUrl(
-        'https://upload.wikimedia.org/wikipedia/commons/thumb/5/5c/US_Navy_070406-N-2959L-756_Members_of_USS_Ronald_Reagan_%28CVN_76%29_First_Class_Association_prepare_and_put_toppings_on_pizzas_in_the_galley_as_part_of_a_special_dinner_prepared_for_the_crew.jpg/169px-thumbnail.jpg',
-      ),
-    ).toBeTruthy()
-    // Long thumb with SVG PNG
-    expect(
-      isWebpCandidateImageUrl(
-        'https://upload.wikimedia.org/wikipedia/commons/thumb/5/5c/US_Navy_070406-N-2959L-756_Members_of_USS_Ronald_Reagan_%28CVN_76%29_First_Class_Association_prepare_and_put_toppings_on_pizzas_in_the_galley_as_part_of_a_special_dinner_prepared_for_the_crew.svg/169px-thumbnail.svg.png',
-      ),
-    ).toBeTruthy()
-
-    // Latex (equations)
-    expect(isWebpCandidateImageUrl('https://wikimedia.org/api/rest_v1/media/math/render/svg/da47d67ac8dcb0be8b68d7bfdc676d9ce9bf1606')).toBeFalsy()
-
-    // WikiHiero (hieroglyphs)
-    // WikiHiero png with URL args
-    expect(isWebpCandidateImageUrl('https://en.wikipedia.org/w/extensions/wikihiero/img/hiero_G1.png?4d556')).toBeTruthy()
-    // WikiHiero png without URL args
-    expect(isWebpCandidateImageUrl('https://en.wikipedia.org/w/extensions/wikihiero/img/hiero_G1.png')).toBeTruthy()
-
-    // Score - is default behaviour
-    expect(isWebpCandidateImageUrl('https://upload.wikimedia.org/score/6/c/6clze8fxoo65795idk91426rskovmgp/6clze8fx.png')).toBeTruthy()
-
-    // Graphoid (charts) - is default behaviour
-    expect(
-      isWebpCandidateImageUrl('https://en.wikipedia.org/api/rest_v1/page/graph/png/COVID-19_pandemic_in_the_United_Kingdom/0/28fe8c45f73e8cc60d45086655340f49cdfd37d0.png'),
-    ).toBeTruthy()
-
-    // Fandom
-    expect(
-      isWebpCandidateImageUrl(
-        'https://static.wikia.nocookie.net/minecraft_de_gamepedia/images/e/ee/Diamantschwert_%28Dungeons%29.png/revision/latest/scale-to-width-down/60?cb=20200409173531',
-      ),
-    ).toBeTruthy()
-
-    // Default behaviour
-    expect(
-      isWebpCandidateImageUrl(
-        'https://maps.wikimedia.org/img/osm-intl,9,52.2789,8.0431,300x300.png?lang=ar&amp;domain=ar.wikipedia.org&amp;title=%D8%A3%D9%88%D8%B3%D9%86%D8%A7%D8%A8%D8%B1%D9%88%D9%83&amp;groups=_0a30d0118ec7c477895dffb596ad2b875958c8fe',
-      ),
-    ).toBeTruthy()
+  test('isWebpCandidate by mime type', async () => {
+    expect(isWebpCandidateImageMimeType('image/jpeg')).toBeTruthy()
+    expect(isWebpCandidateImageMimeType('image/png')).toBeTruthy()
+    expect(isWebpCandidateImageMimeType('image/gif')).toBeFalsy()
+    expect(isWebpCandidateImageMimeType('application/json')).toBeFalsy()
+    expect(isWebpCandidateImageMimeType('image/svg+xml')).toBeFalsy()
+    expect(isWebpCandidateImageMimeType('image/svg')).toBeFalsy()
   })
 
   test('No title normalisation', async () => {
diff --git a/test/unit/webpAndRedirection.test.ts b/test/unit/webpAndRedirection.test.ts
index fc9816ea..a1fd4416 100644
--- a/test/unit/webpAndRedirection.test.ts
+++ b/test/unit/webpAndRedirection.test.ts
@@ -1,7 +1,7 @@
 import { execa } from 'execa'
 import { join } from 'path'
 import * as MwOffliner from '../../src/mwoffliner.lib.js'
-import { writeFilePromise, mkdirPromise, isWebpCandidateImageMimeType, getMimeType } from '../../src/util/index.js'
+import { writeFilePromise, mkdirPromise } from '../../src/util/index.js'
 import { ZimReader } from '@openzim/libzim'
 import * as FileType from 'file-type'
 import rimraf from 'rimraf'
@@ -14,10 +14,6 @@ const testId = join(process.cwd(), `mwo-test-${+now}`)
 
 const articleListUrl = join(testId, '/articleList')
 
-const isWebpCandidateImageUrl = (url) => {
-  return isWebpCandidateImageMimeType(true, getMimeType(url))
-}
-
 test('Webp Option check', async () => {
   await execa('redis-cli flushall', { shell: true })
   await mkdirPromise(testId)
@@ -39,24 +35,10 @@ Real-time computer graphics`
 
   const zimFile = new ZimReader(outFiles[0].outFile)
 
-  // detecting webp URL having png before arguments
-  expect(isWebpCandidateImageUrl('../I/osm-intl%2C9%2C52.2789%2C8.0431%2C300x300.png?lang.svg')).toBeTruthy()
-  // detecting webp URL having jpg before arguments
-  expect(isWebpCandidateImageUrl('../I/osm-intl%2C9%2C52.2789%2C8.0431%2C300x300.jpg?lang.svg')).toBeTruthy()
-  // detecting webp URL having jpeg before arguments
-  expect(isWebpCandidateImageUrl('../I/osm-intl%2C9%2C52.2789%2C8.0431%2C300x300.jpeg?lang.svg')).toBeTruthy()
-  // avoiding detecting webp URL having an escaped question marked
-  expect(!isWebpCandidateImageUrl('../I/osm-intl%2C9%2C52.2789%2C8.0431%2C300x300.jpeg%3Flang.svg')).toBeTruthy()
-  // detecting webp URL having png at last
-  expect(isWebpCandidateImageUrl('../I/osm-intl%2C9%2C52.2789%2C8.0431%2C300x300.png')).toBeTruthy()
-  // detecting webp URL having jpg at last
-  expect(isWebpCandidateImageUrl('../I/osm-intl%2C9%2C52.2789%2C8.0431%2C300x300.jpg')).toBeTruthy()
-  // detecting webp URL having jpeg at last
-  expect(isWebpCandidateImageUrl('../I/osm-intl%2C9%2C52.2789%2C8.0431%2C300x300.jpeg')).toBeTruthy()
   // passed test for png
-  expect(await isWebpPresent('I/Animexample3edit.png.webp', zimFile)).toBeTruthy()
+  expect(await isWebpPresent('I/Animexample3edit.png', zimFile)).toBeTruthy()
   // passed test for jpg
-  expect(await isWebpPresent('I/Claychick.jpg.webp', zimFile)).toBeTruthy()
+  expect(await isWebpPresent('I/Claychick.jpg', zimFile)).toBeTruthy()
   // redirection check successful
   expect(await isRedirectionPresent('href="Real-time_rendering"', zimFile)).toBeTruthy()
   rimraf.sync(testId)