69 files changed, 1084 insertions, 488 deletions
diff --git a/server/lib/activitypub/activity.ts b/server/lib/activitypub/activity.ts
index 1f6ec221e..0fed3e8fd 100644
--- a/server/lib/activitypub/activity.ts
+++ b/server/lib/activitypub/activity.ts
@@ -1,4 +1,5 @@
-import { ActivityType } from '@shared/models'
+import { doJSONRequest } from '@server/helpers/requests'
+import { APObjectId, ActivityObject, ActivityPubActor, ActivityType } from '@shared/models'
 function getAPId (object: string | { id: string }) {
  if (typeof object === 'string') return object
@@ -32,8 +33,19 @@ function buildAvailableActivities (): ActivityType[] {
  ]
 }
+async function fetchAPObject <T extends (ActivityObject | ActivityPubActor)> (object: APObjectId) {
+  if (typeof object === 'string') {
+    const { body } = await doJSONRequest<Exclude<T, string>>(object, { activityPub: true })
+    return body
+  }
+  return object as Exclude<T, string>
+}
 export {
  getAPId,
+  fetchAPObject,
  getActivityStreamDuration,
  buildAvailableActivities,
  getDurationFromActivityStream
diff --git a/server/lib/activitypub/actors/get.ts b/server/lib/activitypub/actors/get.ts
index e73b7d707..b2be3f5fb 100644
--- a/server/lib/activitypub/actors/get.ts
+++ b/server/lib/activitypub/actors/get.ts
@@ -3,8 +3,9 @@ import { logger } from '@server/helpers/logger'
 import { JobQueue } from '@server/lib/job-queue'
 import { ActorLoadByUrlType, loadActorByUrl } from '@server/lib/model-loaders'
 import { MActor, MActorAccountChannelId, MActorAccountChannelIdActor, MActorAccountId, MActorFullActor } from '@server/types/models'
-import { ActivityPubActor } from '@shared/models'
+import { arrayify } from '@shared/core-utils'
-import { getAPId } from '../activity'
+import { ActivityPubActor, APObjectId } from '@shared/models'
+import { fetchAPObject, getAPId } from '../activity'
 import { checkUrlsSameHost } from '../url'
 import { refreshActorIfNeeded } from './refresh'
 import { APActorCreator, fetchRemoteActor } from './shared'
@@ -40,7 +41,7 @@ async function getOrCreateAPActor (
    const { actorObject } = await fetchRemoteActor(actorUrl)
    if (actorObject === undefined) throw new Error('Cannot fetch remote actor ' + actorUrl)
-    // actorUrl is just an alias/rediraction, so process object id instead
+    // actorUrl is just an alias/redirection, so process object id instead
    if (actorObject.id !== actorUrl) return getOrCreateAPActor(actorObject, 'all', recurseIfNeeded, updateCollections)
    // Create the attributed to actor
@@ -68,29 +69,48 @@ async function getOrCreateAPActor (
  return actorRefreshed
 }
-function getOrCreateAPOwner (actorObject: ActivityPubActor, actorUrl: string) {
+async function getOrCreateAPOwner (actorObject: ActivityPubActor, actorUrl: string) {
-  const accountAttributedTo = actorObject.attributedTo.find(a => a.type === 'Person')
+  const accountAttributedTo = await findOwner(actorUrl, actorObject.attributedTo, 'Person')
-  if (!accountAttributedTo) throw new Error('Cannot find account attributed to video channel ' + actorUrl)
+  if (!accountAttributedTo) {
+    throw new Error(`Cannot find account attributed to video channel  ${actorUrl}`)
-  if (checkUrlsSameHost(accountAttributedTo.id, actorUrl) !== true) {
-    throw new Error(`Account attributed to ${accountAttributedTo.id} does not have the same host than actor url ${actorUrl}`)
  }
  try {
    // Don't recurse another time
    const recurseIfNeeded = false
-    return getOrCreateAPActor(accountAttributedTo.id, 'all', recurseIfNeeded)
+    return getOrCreateAPActor(accountAttributedTo, 'all', recurseIfNeeded)
  } catch (err) {
    logger.error('Cannot get or create account attributed to video channel ' + actorUrl)
    throw new Error(err)
  }
 }
+async function findOwner (rootUrl: string, attributedTo: APObjectId[] | APObjectId, type: 'Person' | 'Group') {
+  for (const actorToCheck of arrayify(attributedTo)) {
+    const actorObject = await fetchAPObject<ActivityPubActor>(getAPId(actorToCheck))
+    if (!actorObject) {
+      logger.warn('Unknown attributed to actor %s for owner %s', actorToCheck, rootUrl)
+      continue
+    }
+    if (checkUrlsSameHost(actorObject.id, rootUrl) !== true) {
+      logger.warn(`Account attributed to ${actorObject.id} does not have the same host than owner actor url ${rootUrl}`)
+      continue
+    }
+    if (actorObject.type === type) return actorObject
+  }
+  return undefined
+}
 // ---------------------------------------------------------------------------
 export {
  getOrCreateAPOwner,
-  getOrCreateAPActor
+  getOrCreateAPActor,
+  findOwner
 }
 // ---------------------------------------------------------------------------
diff --git a/server/lib/activitypub/actors/refresh.ts b/server/lib/activitypub/actors/refresh.ts
index 6d8428d66..d15cb5e90 100644
--- a/server/lib/activitypub/actors/refresh.ts
+++ b/server/lib/activitypub/actors/refresh.ts
@@ -1,5 +1,5 @@
 import { logger, loggerTagsFactory } from '@server/helpers/logger'
-import { PromiseCache } from '@server/helpers/promise-cache'
+import { CachePromiseFactory } from '@server/helpers/promise-cache'
 import { PeerTubeRequestError } from '@server/helpers/requests'
 import { ActorLoadByUrlType } from '@server/lib/model-loaders'
 import { ActorModel } from '@server/models/actor/actor'
@@ -16,7 +16,7 @@ type RefreshOptions <T> = {
  fetchedType: ActorLoadByUrlType
 }
-const promiseCache = new PromiseCache(doRefresh, (options: RefreshOptions<MActorFull | MActorAccountChannelId>) => options.actor.url)
+const promiseCache = new CachePromiseFactory(doRefresh, (options: RefreshOptions<MActorFull | MActorAccountChannelId>) => options.actor.url)
 function refreshActorIfNeeded <T extends MActorFull | MActorAccountChannelId> (options: RefreshOptions<T>): RefreshResult <T> {
  const actorArg = options.actor
diff --git a/server/lib/activitypub/context.ts b/server/lib/activitypub/context.ts
index a3ca52a31..750276a11 100644
--- a/server/lib/activitypub/context.ts
+++ b/server/lib/activitypub/context.ts
@@ -46,6 +46,19 @@ const contextStore: { [ id in ContextType ]: (string | { [ id: string ]: string
    Infohash: 'pt:Infohash',
+    tileWidth: {
+      '@type': 'sc:Number',
+      '@id': 'pt:tileWidth'
+    },
+    tileHeight: {
+      '@type': 'sc:Number',
+      '@id': 'pt:tileHeight'
+    },
+    tileDuration: {
+      '@type': 'sc:Number',
+      '@id': 'pt:tileDuration'
+    },
    originallyPublishedAt: 'sc:datePublished',
    views: {
      '@type': 'sc:Number',
diff --git a/server/lib/activitypub/playlists/create-update.ts b/server/lib/activitypub/playlists/create-update.ts
index 9339e8ea4..b24299f29 100644
--- a/server/lib/activitypub/playlists/create-update.ts
+++ b/server/lib/activitypub/playlists/create-update.ts
@@ -4,7 +4,7 @@ import { retryTransactionWrapper } from '@server/helpers/database-utils'
 import { logger, loggerTagsFactory } from '@server/helpers/logger'
 import { CRAWL_REQUEST_CONCURRENCY } from '@server/initializers/constants'
 import { sequelizeTypescript } from '@server/initializers/database'
-import { updatePlaylistMiniatureFromUrl } from '@server/lib/thumbnail'
+import { updateRemotePlaylistMiniatureFromUrl } from '@server/lib/thumbnail'
 import { VideoPlaylistModel } from '@server/models/video/video-playlist'
 import { VideoPlaylistElementModel } from '@server/models/video/video-playlist-element'
 import { FilteredModelAttributes } from '@server/types'
@@ -77,7 +77,7 @@ async function setVideoChannel (playlistObject: PlaylistObject, playlistAttribut
    throw new Error('Not attributed to for playlist object ' + getAPId(playlistObject))
  }
-  const actor = await getOrCreateAPActor(playlistObject.attributedTo[0], 'all')
+  const actor = await getOrCreateAPActor(getAPId(playlistObject.attributedTo[0]), 'all')
  if (!actor.VideoChannel) {
    logger.warn('Playlist "attributedTo" %s is not a video channel.', playlistObject.id, { playlistObject, ...lTags(playlistObject.id) })
@@ -104,7 +104,7 @@ async function updatePlaylistThumbnail (playlistObject: PlaylistObject, playlist
    let thumbnailModel: MThumbnail
    try {
-      thumbnailModel = await updatePlaylistMiniatureFromUrl({ downloadUrl: playlistObject.icon.url, playlist })
+      thumbnailModel = await updateRemotePlaylistMiniatureFromUrl({ downloadUrl: playlistObject.icon.url, playlist })
      await playlist.setAndSaveThumbnail(thumbnailModel, undefined)
    } catch (err) {
      logger.warn('Cannot set thumbnail of %s.', playlistObject.id, { err, ...lTags(playlistObject.id, playlist.uuid, playlist.url) })
diff --git a/server/lib/activitypub/playlists/get.ts b/server/lib/activitypub/playlists/get.ts
index bfaf52cc9..c34554d69 100644
--- a/server/lib/activitypub/playlists/get.ts
+++ b/server/lib/activitypub/playlists/get.ts
@@ -1,12 +1,12 @@
 import { VideoPlaylistModel } from '@server/models/video/video-playlist'
 import { MVideoPlaylistFullSummary } from '@server/types/models'
-import { APObject } from '@shared/models'
+import { APObjectId } from '@shared/models'
 import { getAPId } from '../activity'
 import { createOrUpdateVideoPlaylist } from './create-update'
 import { scheduleRefreshIfNeeded } from './refresh'
 import { fetchRemoteVideoPlaylist } from './shared'
-async function getOrCreateAPVideoPlaylist (playlistObjectArg: APObject): Promise<MVideoPlaylistFullSummary> {
+async function getOrCreateAPVideoPlaylist (playlistObjectArg: APObjectId): Promise<MVideoPlaylistFullSummary> {
  const playlistUrl = getAPId(playlistObjectArg)
  const playlistFromDatabase = await VideoPlaylistModel.loadByUrlWithAccountAndChannelSummary(playlistUrl)
diff --git a/server/lib/activitypub/process/process-create.ts b/server/lib/activitypub/process/process-create.ts
index 1e6e8956c..e89d1ab45 100644
--- a/server/lib/activitypub/process/process-create.ts
+++ b/server/lib/activitypub/process/process-create.ts
@@ -1,13 +1,24 @@
 import { isBlockedByServerOrAccount } from '@server/lib/blocklist'
 import { isRedundancyAccepted } from '@server/lib/redundancy'
 import { VideoModel } from '@server/models/video/video'
-import { ActivityCreate, CacheFileObject, PlaylistObject, VideoCommentObject, VideoObject, WatchActionObject } from '@shared/models'
+import {
+  AbuseObject,
+  ActivityCreate,
+  ActivityCreateObject,
+  ActivityObject,
+  CacheFileObject,
+  PlaylistObject,
+  VideoCommentObject,
+  VideoObject,
+  WatchActionObject
+} from '@shared/models'
 import { retryTransactionWrapper } from '../../../helpers/database-utils'
 import { logger } from '../../../helpers/logger'
 import { sequelizeTypescript } from '../../../initializers/database'
 import { APProcessorOptions } from '../../../types/activitypub-processor.model'
 import { MActorSignature, MCommentOwnerVideo, MVideoAccountLightBlacklistAllFiles } from '../../../types/models'
 import { Notifier } from '../../notifier'
+import { fetchAPObject } from '../activity'
 import { createOrUpdateCacheFile } from '../cache-file'
 import { createOrUpdateLocalVideoViewer } from '../local-video-viewer'
 import { createOrUpdateVideoPlaylist } from '../playlists'
@@ -15,35 +26,35 @@ import { forwardVideoRelatedActivity } from '../send/shared/send-utils'
 import { resolveThread } from '../video-comments'
 import { getOrCreateAPVideo } from '../videos'
-async function processCreateActivity (options: APProcessorOptions<ActivityCreate>) {
+async function processCreateActivity (options: APProcessorOptions<ActivityCreate<ActivityCreateObject>>) {
  const { activity, byActor } = options
  // Only notify if it is not from a fetcher job
  const notify = options.fromFetch !== true
-  const activityObject = activity.object
+  const activityObject = await fetchAPObject<Exclude<ActivityObject, AbuseObject>>(activity.object)
  const activityType = activityObject.type
  if (activityType === 'Video') {
-    return processCreateVideo(activity, notify)
+    return processCreateVideo(activityObject, notify)
  }
  if (activityType === 'Note') {
    // Comments will be fetched from videos
    if (options.fromFetch) return
-    return retryTransactionWrapper(processCreateVideoComment, activity, byActor, notify)
+    return retryTransactionWrapper(processCreateVideoComment, activity, activityObject, byActor, notify)
  }
  if (activityType === 'WatchAction') {
-    return retryTransactionWrapper(processCreateWatchAction, activity)
+    return retryTransactionWrapper(processCreateWatchAction, activityObject)
  }
  if (activityType === 'CacheFile') {
-    return retryTransactionWrapper(processCreateCacheFile, activity, byActor)
+    return retryTransactionWrapper(processCreateCacheFile, activity, activityObject, byActor)
  }
  if (activityType === 'Playlist') {
-    return retryTransactionWrapper(processCreatePlaylist, activity, byActor)
+    return retryTransactionWrapper(processCreatePlaylist, activity, activityObject, byActor)
  }
  logger.warn('Unknown activity object type %s when creating activity.', activityType, { activity: activity.id })
@@ -58,9 +69,7 @@ export {
 // ---------------------------------------------------------------------------
-async function processCreateVideo (activity: ActivityCreate, notify: boolean) {
+async function processCreateVideo (videoToCreateData: VideoObject, notify: boolean) {
-  const videoToCreateData = activity.object as VideoObject
  const syncParam = { rates: false, shares: false, comments: false, thumbnail: true, refreshVideo: false }
  const { video, created } = await getOrCreateAPVideo({ videoObject: videoToCreateData, syncParam })
@@ -69,11 +78,13 @@ async function processCreateVideo (activity: ActivityCreate, notify: boolean) {
  return video
 }
-async function processCreateCacheFile (activity: ActivityCreate, byActor: MActorSignature) {
+async function processCreateCacheFile (
+  activity: ActivityCreate<CacheFileObject | string>,
+  cacheFile: CacheFileObject,
+  byActor: MActorSignature
+) {
  if (await isRedundancyAccepted(activity, byActor) !== true) return
-  const cacheFile = activity.object as CacheFileObject
  const { video } = await getOrCreateAPVideo({ videoObject: cacheFile.object })
  await sequelizeTypescript.transaction(async t => {
@@ -87,9 +98,7 @@ async function processCreateCacheFile (activity: ActivityCreate, byActor: MActor
  }
 }
-async function processCreateWatchAction (activity: ActivityCreate) {
+async function processCreateWatchAction (watchAction: WatchActionObject) {
-  const watchAction = activity.object as WatchActionObject
  if (watchAction.actionStatus !== 'CompletedActionStatus') return
  const video = await VideoModel.loadByUrl(watchAction.object)
@@ -100,8 +109,12 @@ async function processCreateWatchAction (activity: ActivityCreate) {
  })
 }
-async function processCreateVideoComment (activity: ActivityCreate, byActor: MActorSignature, notify: boolean) {
+async function processCreateVideoComment (
-  const commentObject = activity.object as VideoCommentObject
+  activity: ActivityCreate<VideoCommentObject | string>,
+  commentObject: VideoCommentObject,
+  byActor: MActorSignature,
+  notify: boolean
+) {
  const byAccount = byActor.Account
  if (!byAccount) throw new Error('Cannot create video comment with the non account actor ' + byActor.url)
@@ -144,8 +157,11 @@ async function processCreateVideoComment (activity: ActivityCreate, byActor: MAc
  if (created && notify) Notifier.Instance.notifyOnNewComment(comment)
 }
-async function processCreatePlaylist (activity: ActivityCreate, byActor: MActorSignature) {
+async function processCreatePlaylist (
-  const playlistObject = activity.object as PlaylistObject
+  activity: ActivityCreate<PlaylistObject | string>,
+  playlistObject: PlaylistObject,
+  byActor: MActorSignature
+) {
  const byAccount = byActor.Account
  if (!byAccount) throw new Error('Cannot create video playlist with the non account actor ' + byActor.url)
diff --git a/server/lib/activitypub/process/process-dislike.ts b/server/lib/activitypub/process/process-dislike.ts
index 44e349b22..4e270f917 100644
--- a/server/lib/activitypub/process/process-dislike.ts
+++ b/server/lib/activitypub/process/process-dislike.ts
@@ -1,5 +1,5 @@
 import { VideoModel } from '@server/models/video/video'
-import { ActivityCreate, ActivityDislike, DislikeObject } from '@shared/models'
+import { ActivityDislike } from '@shared/models'
 import { retryTransactionWrapper } from '../../../helpers/database-utils'
 import { sequelizeTypescript } from '../../../initializers/database'
 import { AccountVideoRateModel } from '../../../models/account/account-video-rate'
@@ -7,7 +7,7 @@ import { APProcessorOptions } from '../../../types/activitypub-processor.model'
 import { MActorSignature } from '../../../types/models'
 import { federateVideoIfNeeded, getOrCreateAPVideo } from '../videos'
-async function processDislikeActivity (options: APProcessorOptions<ActivityCreate | ActivityDislike>) {
+async function processDislikeActivity (options: APProcessorOptions<ActivityDislike>) {
  const { activity, byActor } = options
  return retryTransactionWrapper(processDislike, activity, byActor)
 }
@@ -20,11 +20,8 @@ export {
 // ---------------------------------------------------------------------------
-async function processDislike (activity: ActivityCreate | ActivityDislike, byActor: MActorSignature) {
+async function processDislike (activity: ActivityDislike, byActor: MActorSignature) {
-  const dislikeObject = activity.type === 'Dislike'
+  const dislikeObject = activity.object
-    ? activity.object
-    : (activity.object as DislikeObject).object
  const byAccount = byActor.Account
  if (!byAccount) throw new Error('Cannot create dislike with the non account actor ' + byActor.url)
diff --git a/server/lib/activitypub/process/process-flag.ts b/server/lib/activitypub/process/process-flag.ts
index 10f58ef27..bea285670 100644
--- a/server/lib/activitypub/process/process-flag.ts
+++ b/server/lib/activitypub/process/process-flag.ts
@@ -3,7 +3,7 @@ import { AccountModel } from '@server/models/account/account'
 import { VideoModel } from '@server/models/video/video'
 import { VideoCommentModel } from '@server/models/video/video-comment'
 import { abusePredefinedReasonsMap } from '@shared/core-utils/abuse'
-import { AbuseObject, AbuseState, ActivityCreate, ActivityFlag } from '@shared/models'
+import { AbuseState, ActivityFlag } from '@shared/models'
 import { retryTransactionWrapper } from '../../../helpers/database-utils'
 import { logger } from '../../../helpers/logger'
 import { sequelizeTypescript } from '../../../initializers/database'
@@ -11,7 +11,7 @@ import { getAPId } from '../../../lib/activitypub/activity'
 import { APProcessorOptions } from '../../../types/activitypub-processor.model'
 import { MAccountDefault, MActorSignature, MCommentOwnerVideo } from '../../../types/models'
-async function processFlagActivity (options: APProcessorOptions<ActivityCreate | ActivityFlag>) {
+async function processFlagActivity (options: APProcessorOptions<ActivityFlag>) {
  const { activity, byActor } = options
  return retryTransactionWrapper(processCreateAbuse, activity, byActor)
@@ -25,9 +25,7 @@ export {
 // ---------------------------------------------------------------------------
-async function processCreateAbuse (activity: ActivityCreate | ActivityFlag, byActor: MActorSignature) {
+async function processCreateAbuse (flag: ActivityFlag, byActor: MActorSignature) {
-  const flag = activity.type === 'Flag' ? activity : (activity.object as AbuseObject)
  const account = byActor.Account
  if (!account) throw new Error('Cannot create abuse with the non account actor ' + byActor.url)
diff --git a/server/lib/activitypub/process/process-undo.ts b/server/lib/activitypub/process/process-undo.ts
index 99423a72b..25f68724d 100644
--- a/server/lib/activitypub/process/process-undo.ts
+++ b/server/lib/activitypub/process/process-undo.ts
@@ -1,6 +1,14 @@
 import { VideoModel } from '@server/models/video/video'
-import { ActivityAnnounce, ActivityFollow, ActivityLike, ActivityUndo, CacheFileObject } from '../../../../shared/models/activitypub'
+import {
-import { DislikeObject } from '../../../../shared/models/activitypub/objects'
+  ActivityAnnounce,
+  ActivityCreate,
+  ActivityDislike,
+  ActivityFollow,
+  ActivityLike,
+  ActivityUndo,
+  ActivityUndoObject,
+  CacheFileObject
+} from '../../../../shared/models/activitypub'
 import { retryTransactionWrapper } from '../../../helpers/database-utils'
 import { logger } from '../../../helpers/logger'
 import { sequelizeTypescript } from '../../../initializers/database'
@@ -11,10 +19,11 @@ import { VideoRedundancyModel } from '../../../models/redundancy/video-redundanc
 import { VideoShareModel } from '../../../models/video/video-share'
 import { APProcessorOptions } from '../../../types/activitypub-processor.model'
 import { MActorSignature } from '../../../types/models'
+import { fetchAPObject } from '../activity'
 import { forwardVideoRelatedActivity } from '../send/shared/send-utils'
 import { federateVideoIfNeeded, getOrCreateAPVideo } from '../videos'
-async function processUndoActivity (options: APProcessorOptions<ActivityUndo>) {
+async function processUndoActivity (options: APProcessorOptions<ActivityUndo<ActivityUndoObject>>) {
  const { activity, byActor } = options
  const activityToUndo = activity.object
@@ -23,8 +32,10 @@ async function processUndoActivity (options: APProcessorOptions<ActivityUndo>) {
  }
  if (activityToUndo.type === 'Create') {
-    if (activityToUndo.object.type === 'CacheFile') {
+    const objectToUndo = await fetchAPObject<CacheFileObject>(activityToUndo.object)
-      return retryTransactionWrapper(processUndoCacheFile, byActor, activity)
+    if (objectToUndo.type === 'CacheFile') {
+      return retryTransactionWrapper(processUndoCacheFile, byActor, activity, objectToUndo)
    }
  }
@@ -53,8 +64,8 @@ export {
 // ---------------------------------------------------------------------------
-async function processUndoLike (byActor: MActorSignature, activity: ActivityUndo) {
+async function processUndoLike (byActor: MActorSignature, activity: ActivityUndo<ActivityLike>) {
-  const likeActivity = activity.object as ActivityLike
+  const likeActivity = activity.object
  const { video: onlyVideo } = await getOrCreateAPVideo({ videoObject: likeActivity.object })
  // We don't care about likes of remote videos
@@ -78,12 +89,10 @@ async function processUndoLike (byActor: MActorSignature, activity: ActivityUndo
  })
 }
-async function processUndoDislike (byActor: MActorSignature, activity: ActivityUndo) {
+async function processUndoDislike (byActor: MActorSignature, activity: ActivityUndo<ActivityDislike>) {
-  const dislike = activity.object.type === 'Dislike'
+  const dislikeActivity = activity.object
-    ? activity.object
-    : activity.object.object as DislikeObject
-  const { video: onlyVideo } = await getOrCreateAPVideo({ videoObject: dislike.object })
+  const { video: onlyVideo } = await getOrCreateAPVideo({ videoObject: dislikeActivity.object })
  // We don't care about likes of remote videos
  if (!onlyVideo.isOwned()) return
@@ -91,7 +100,7 @@ async function processUndoDislike (byActor: MActorSignature, activity: ActivityU
    if (!byActor.Account) throw new Error('Unknown account ' + byActor.url)
    const video = await VideoModel.loadFull(onlyVideo.id, t)
-    const rate = await AccountVideoRateModel.loadByAccountAndVideoOrUrl(byActor.Account.id, video.id, dislike.id, t)
+    const rate = await AccountVideoRateModel.loadByAccountAndVideoOrUrl(byActor.Account.id, video.id, dislikeActivity.id, t)
    if (!rate || rate.type !== 'dislike') {
      logger.warn(`Unknown dislike by account %d for video %d.`, byActor.Account.id, video.id)
      return
@@ -107,9 +116,11 @@ async function processUndoDislike (byActor: MActorSignature, activity: ActivityU
 // ---------------------------------------------------------------------------
-async function processUndoCacheFile (byActor: MActorSignature, activity: ActivityUndo) {
+async function processUndoCacheFile (
-  const cacheFileObject = activity.object.object as CacheFileObject
+  byActor: MActorSignature,
+  activity: ActivityUndo<ActivityCreate<CacheFileObject>>,
+  cacheFileObject: CacheFileObject
+) {
  const { video } = await getOrCreateAPVideo({ videoObject: cacheFileObject.object })
  return sequelizeTypescript.transaction(async t => {
diff --git a/server/lib/activitypub/process/process-update.ts b/server/lib/activitypub/process/process-update.ts
index 4afdbd430..9caa74e04 100644
--- a/server/lib/activitypub/process/process-update.ts
+++ b/server/lib/activitypub/process/process-update.ts
@@ -1,5 +1,5 @@
 import { isRedundancyAccepted } from '@server/lib/redundancy'
-import { ActivityUpdate, CacheFileObject, VideoObject } from '../../../../shared/models/activitypub'
+import { ActivityUpdate, ActivityUpdateObject, CacheFileObject, VideoObject } from '../../../../shared/models/activitypub'
 import { ActivityPubActor } from '../../../../shared/models/activitypub/activitypub-actor'
 import { PlaylistObject } from '../../../../shared/models/activitypub/objects/playlist-object'
 import { isCacheFileObjectValid } from '../../../helpers/custom-validators/activitypub/cache-file'
@@ -10,16 +10,18 @@ import { sequelizeTypescript } from '../../../initializers/database'
 import { ActorModel } from '../../../models/actor/actor'
 import { APProcessorOptions } from '../../../types/activitypub-processor.model'
 import { MActorFull, MActorSignature } from '../../../types/models'
+import { fetchAPObject } from '../activity'
 import { APActorUpdater } from '../actors/updater'
 import { createOrUpdateCacheFile } from '../cache-file'
 import { createOrUpdateVideoPlaylist } from '../playlists'
 import { forwardVideoRelatedActivity } from '../send/shared/send-utils'
 import { APVideoUpdater, getOrCreateAPVideo } from '../videos'
-async function processUpdateActivity (options: APProcessorOptions<ActivityUpdate>) {
+async function processUpdateActivity (options: APProcessorOptions<ActivityUpdate<ActivityUpdateObject>>) {
  const { activity, byActor } = options
-  const objectType = activity.object.type
+  const object = await fetchAPObject(activity.object)
+  const objectType = object.type
  if (objectType === 'Video') {
    return retryTransactionWrapper(processUpdateVideo, activity)
@@ -28,17 +30,17 @@ async function processUpdateActivity (options: APProcessorOptions<ActivityUpdate
  if (objectType === 'Person' || objectType === 'Application' || objectType === 'Group') {
    // We need more attributes
    const byActorFull = await ActorModel.loadByUrlAndPopulateAccountAndChannel(byActor.url)
-    return retryTransactionWrapper(processUpdateActor, byActorFull, activity)
+    return retryTransactionWrapper(processUpdateActor, byActorFull, object)
  }
  if (objectType === 'CacheFile') {
    // We need more attributes
    const byActorFull = await ActorModel.loadByUrlAndPopulateAccountAndChannel(byActor.url)
-    return retryTransactionWrapper(processUpdateCacheFile, byActorFull, activity)
+    return retryTransactionWrapper(processUpdateCacheFile, byActorFull, activity, object)
  }
  if (objectType === 'Playlist') {
-    return retryTransactionWrapper(processUpdatePlaylist, byActor, activity)
+    return retryTransactionWrapper(processUpdatePlaylist, byActor, activity, object)
  }
  return undefined
@@ -52,7 +54,7 @@ export {
 // ---------------------------------------------------------------------------
-async function processUpdateVideo (activity: ActivityUpdate) {
+async function processUpdateVideo (activity: ActivityUpdate<VideoObject | string>) {
  const videoObject = activity.object as VideoObject
  if (sanitizeAndCheckVideoTorrentObject(videoObject) === false) {
@@ -72,11 +74,13 @@ async function processUpdateVideo (activity: ActivityUpdate) {
  return updater.update(activity.to)
 }
-async function processUpdateCacheFile (byActor: MActorSignature, activity: ActivityUpdate) {
+async function processUpdateCacheFile (
+  byActor: MActorSignature,
+  activity: ActivityUpdate<CacheFileObject | string>,
+  cacheFileObject: CacheFileObject
+) {
  if (await isRedundancyAccepted(activity, byActor) !== true) return
-  const cacheFileObject = activity.object as CacheFileObject
  if (!isCacheFileObjectValid(cacheFileObject)) {
    logger.debug('Cache file object sent by update is not valid.', { cacheFileObject })
    return undefined
@@ -96,19 +100,19 @@ async function processUpdateCacheFile (byActor: MActorSignature, activity: Activ
  }
 }
-async function processUpdateActor (actor: MActorFull, activity: ActivityUpdate) {
+async function processUpdateActor (actor: MActorFull, actorObject: ActivityPubActor) {
-  const actorObject = activity.object as ActivityPubActor
  logger.debug('Updating remote account "%s".', actorObject.url)
  const updater = new APActorUpdater(actorObject, actor)
  return updater.update()
 }
-async function processUpdatePlaylist (byActor: MActorSignature, activity: ActivityUpdate) {
+async function processUpdatePlaylist (
-  const playlistObject = activity.object as PlaylistObject
+  byActor: MActorSignature,
+  activity: ActivityUpdate<PlaylistObject | string>,
+  playlistObject: PlaylistObject
+) {
  const byAccount = byActor.Account
  if (!byAccount) throw new Error('Cannot update video playlist with the non account actor ' + byActor.url)
  await createOrUpdateVideoPlaylist(playlistObject, activity.to)
diff --git a/server/lib/activitypub/send/send-create.ts b/server/lib/activitypub/send/send-create.ts
index 0e996ab80..2cd4db14d 100644
--- a/server/lib/activitypub/send/send-create.ts
+++ b/server/lib/activitypub/send/send-create.ts
@@ -1,6 +1,14 @@
 import { Transaction } from 'sequelize'
 import { getServerActor } from '@server/models/application/application'
-import { ActivityAudience, ActivityCreate, ContextType, VideoPlaylistPrivacy, VideoPrivacy } from '@shared/models'
+import {
+  ActivityAudience,
+  ActivityCreate,
+  ActivityCreateObject,
+  ContextType,
+  VideoCommentObject,
+  VideoPlaylistPrivacy,
+  VideoPrivacy
+} from '@shared/models'
 import { logger, loggerTagsFactory } from '../../../helpers/logger'
 import { VideoCommentModel } from '../../../models/video/video-comment'
 import {
@@ -107,7 +115,7 @@ async function sendCreateVideoComment (comment: MCommentOwnerVideo, transaction:
  const byActor = comment.Account.Actor
  const threadParentComments = await VideoCommentModel.listThreadParentComments(comment, transaction)
-  const commentObject = comment.toActivityPubObject(threadParentComments)
+  const commentObject = comment.toActivityPubObject(threadParentComments) as VideoCommentObject
  const actorsInvolvedInComment = await getActorsInvolvedInVideo(comment.Video, transaction)
  // Add the actor that commented too
@@ -168,7 +176,12 @@ async function sendCreateVideoComment (comment: MCommentOwnerVideo, transaction:
  })
 }
-function buildCreateActivity (url: string, byActor: MActorLight, object: any, audience?: ActivityAudience): ActivityCreate {
+function buildCreateActivity <T extends ActivityCreateObject> (
+  url: string,
+  byActor: MActorLight,
+  object: T,
+  audience?: ActivityAudience
+): ActivityCreate<T> {
  if (!audience) audience = getAudience(byActor)
  return audiencify(
@@ -176,7 +189,9 @@ function buildCreateActivity (url: string, byActor: MActorLight, object: any, au
      type: 'Create' as 'Create',
      id: url + '/activity',
      actor: byActor.url,
-      object: audiencify(object, audience)
+      object: typeof object === 'string'
+        ? object
+        : audiencify(object, audience)
    },
    audience
  )
diff --git a/server/lib/activitypub/send/send-undo.ts b/server/lib/activitypub/send/send-undo.ts
index b8eb47ff6..b0b48c9c4 100644
--- a/server/lib/activitypub/send/send-undo.ts
+++ b/server/lib/activitypub/send/send-undo.ts
@@ -1,14 +1,5 @@
 import { Transaction } from 'sequelize'
-import {
+import { ActivityAudience, ActivityDislike, ActivityLike, ActivityUndo, ActivityUndoObject, ContextType } from '@shared/models'
-  ActivityAnnounce,
-  ActivityAudience,
-  ActivityCreate,
-  ActivityDislike,
-  ActivityFollow,
-  ActivityLike,
-  ActivityUndo,
-  ContextType
-} from '@shared/models'
 import { logger } from '../../../helpers/logger'
 import { VideoModel } from '../../../models/video/video'
 import {
@@ -128,12 +119,12 @@ export {
 // ---------------------------------------------------------------------------
-function undoActivityData (
+function undoActivityData <T extends ActivityUndoObject> (
  url: string,
  byActor: MActorAudience,
-  object: ActivityFollow | ActivityLike | ActivityDislike | ActivityCreate | ActivityAnnounce,
+  object: T,
  audience?: ActivityAudience
-): ActivityUndo {
+): ActivityUndo<T> {
  if (!audience) audience = getAudience(byActor)
  return audiencify(
@@ -151,7 +142,7 @@ async function sendUndoVideoRelatedActivity (options: {
  byActor: MActor
  video: MVideoAccountLight
  url: string
-  activity: ActivityFollow | ActivityCreate | ActivityAnnounce
+  activity: ActivityUndoObject
  contextType: ContextType
  transaction: Transaction
 }) {
diff --git a/server/lib/activitypub/send/send-update.ts b/server/lib/activitypub/send/send-update.ts
index 379e2d9d8..f3fb741c6 100644
--- a/server/lib/activitypub/send/send-update.ts
+++ b/server/lib/activitypub/send/send-update.ts
@@ -1,6 +1,6 @@
 import { Transaction } from 'sequelize'
 import { getServerActor } from '@server/models/application/application'
-import { ActivityAudience, ActivityUpdate, VideoPlaylistPrivacy, VideoPrivacy } from '@shared/models'
+import { ActivityAudience, ActivityUpdate, ActivityUpdateObject, VideoPlaylistPrivacy, VideoPrivacy } from '@shared/models'
 import { logger } from '../../../helpers/logger'
 import { AccountModel } from '../../../models/account/account'
 import { VideoModel } from '../../../models/video/video'
@@ -10,8 +10,7 @@ import {
  MActor,
  MActorLight,
  MChannelDefault,
-  MVideoAP,
+  MVideoAPLight,
-  MVideoAPWithoutCaption,
  MVideoPlaylistFull,
  MVideoRedundancyVideo
 } from '../../../types/models'
@@ -20,10 +19,10 @@ import { getUpdateActivityPubUrl } from '../url'
 import { getActorsInvolvedInVideo } from './shared'
 import { broadcastToFollowers, sendVideoRelatedActivity } from './shared/send-utils'
-async function sendUpdateVideo (videoArg: MVideoAPWithoutCaption, transaction: Transaction, overriddenByActor?: MActor) {
+async function sendUpdateVideo (videoArg: MVideoAPLight, transaction: Transaction, overriddenByActor?: MActor) {
-  const video = videoArg as MVideoAP
+  if (!videoArg.hasPrivacyForFederation()) return undefined
-  if (!video.hasPrivacyForFederation()) return undefined
+  const video = await videoArg.lightAPToFullAP(transaction)
  logger.info('Creating job to update video %s.', video.url)
@@ -31,11 +30,6 @@ async function sendUpdateVideo (videoArg: MVideoAPWithoutCaption, transaction: T
  const url = getUpdateActivityPubUrl(video.url, video.updatedAt.toISOString())
-  // Needed to build the AP object
-  if (!video.VideoCaptions) {
-    video.VideoCaptions = await video.$get('VideoCaptions', { transaction })
-  }
  const videoObject = await video.toActivityPubObject()
  const audience = getAudience(byActor, video.privacy === VideoPrivacy.PUBLIC)
@@ -143,7 +137,12 @@ export {
 // ---------------------------------------------------------------------------
-function buildUpdateActivity (url: string, byActor: MActorLight, object: any, audience?: ActivityAudience): ActivityUpdate {
+function buildUpdateActivity (
+  url: string,
+  byActor: MActorLight,
+  object: ActivityUpdateObject,
+  audience?: ActivityAudience
+): ActivityUpdate<ActivityUpdateObject> {
  if (!audience) audience = getAudience(byActor)
  return audiencify(
diff --git a/server/lib/activitypub/videos/federate.ts b/server/lib/activitypub/videos/federate.ts
index bd0c54b0c..d7e251153 100644
--- a/server/lib/activitypub/videos/federate.ts
+++ b/server/lib/activitypub/videos/federate.ts
@@ -1,10 +1,9 @@
 import { Transaction } from 'sequelize/types'
-import { isArray } from '@server/helpers/custom-validators/misc'
+import { MVideoAP, MVideoAPLight } from '@server/types/models'
-import { MVideoAP, MVideoAPWithoutCaption } from '@server/types/models'
 import { sendCreateVideo, sendUpdateVideo } from '../send'
 import { shareVideoByServerAndChannel } from '../share'
-async function federateVideoIfNeeded (videoArg: MVideoAPWithoutCaption, isNewVideo: boolean, transaction?: Transaction) {
+async function federateVideoIfNeeded (videoArg: MVideoAPLight, isNewVideo: boolean, transaction?: Transaction) {
  const video = videoArg as MVideoAP
  if (
@@ -13,13 +12,7 @@ async function federateVideoIfNeeded (videoArg: MVideoAPWithoutCaption, isNewVid
    // Check the video is public/unlisted and published
    video.hasPrivacyForFederation() && video.hasStateForFederation()
  ) {
-    // Fetch more attributes that we will need to serialize in AP object
+    const video = await videoArg.lightAPToFullAP(transaction)
-    if (isArray(video.VideoCaptions) === false) {
-      video.VideoCaptions = await video.$get('VideoCaptions', {
-        attributes: [ 'filename', 'language' ],
-        transaction
-      })
-    }
    if (isNewVideo) {
      // Now we'll add the video's meta data to our followers
diff --git a/server/lib/activitypub/videos/get.ts b/server/lib/activitypub/videos/get.ts
index 14ba55034..92387c5d4 100644
--- a/server/lib/activitypub/videos/get.ts
+++ b/server/lib/activitypub/videos/get.ts
@@ -3,7 +3,7 @@ import { logger } from '@server/helpers/logger'
 import { JobQueue } from '@server/lib/job-queue'
 import { loadVideoByUrl, VideoLoadByUrlType } from '@server/lib/model-loaders'
 import { MVideoAccountLightBlacklistAllFiles, MVideoImmutable, MVideoThumbnail } from '@server/types/models'
-import { APObject } from '@shared/models'
+import { APObjectId } from '@shared/models'
 import { getAPId } from '../activity'
 import { refreshVideoIfNeeded } from './refresh'
 import { APVideoCreator, fetchRemoteVideo, SyncParam, syncVideoExternalAttributes } from './shared'
@@ -15,21 +15,21 @@ type GetVideoResult <T> = Promise<{
 }>
 type GetVideoParamAll = {
-  videoObject: APObject
+  videoObject: APObjectId
  syncParam?: SyncParam
  fetchType?: 'all'
  allowRefresh?: boolean
 }
 type GetVideoParamImmutable = {
-  videoObject: APObject
+  videoObject: APObjectId
  syncParam?: SyncParam
  fetchType: 'only-immutable-attributes'
  allowRefresh: false
 }
 type GetVideoParamOther = {
-  videoObject: APObject
+  videoObject: APObjectId
  syncParam?: SyncParam
  fetchType?: 'all' | 'only-video'
  allowRefresh?: boolean
diff --git a/server/lib/activitypub/videos/shared/abstract-builder.ts b/server/lib/activitypub/videos/shared/abstract-builder.ts
index c0b92c93d..98c2f58eb 100644
--- a/server/lib/activitypub/videos/shared/abstract-builder.ts
+++ b/server/lib/activitypub/videos/shared/abstract-builder.ts
@@ -1,8 +1,9 @@
 import { CreationAttributes, Transaction } from 'sequelize/types'
 import { deleteAllModels, filterNonExistingModels } from '@server/helpers/database-utils'
 import { logger, LoggerTagsFn } from '@server/helpers/logger'
-import { updatePlaceholderThumbnail, updateVideoMiniatureFromUrl } from '@server/lib/thumbnail'
+import { updateRemoteVideoThumbnail } from '@server/lib/thumbnail'
 import { setVideoTags } from '@server/lib/video'
+import { StoryboardModel } from '@server/models/video/storyboard'
 import { VideoCaptionModel } from '@server/models/video/video-caption'
 import { VideoFileModel } from '@server/models/video/video-file'
 import { VideoLiveModel } from '@server/models/video/video-live'
@@ -10,20 +11,19 @@ import { VideoStreamingPlaylistModel } from '@server/models/video/video-streamin
 import {
  MStreamingPlaylistFiles,
  MStreamingPlaylistFilesVideo,
-  MThumbnail,
  MVideoCaption,
  MVideoFile,
  MVideoFullLight,
  MVideoThumbnail
 } from '@server/types/models'
 import { ActivityTagObject, ThumbnailType, VideoObject, VideoStreamingPlaylistType } from '@shared/models'
-import { getOrCreateAPActor } from '../../actors'
+import { findOwner, getOrCreateAPActor } from '../../actors'
-import { checkUrlsSameHost } from '../../url'
 import {
  getCaptionAttributesFromObject,
  getFileAttributesFromUrl,
  getLiveAttributesFromObject,
  getPreviewFromIcons,
+  getStoryboardAttributeFromObject,
  getStreamingPlaylistAttributesFromObject,
  getTagsFromObject,
  getThumbnailFromIcons
@@ -35,38 +35,40 @@ export abstract class APVideoAbstractBuilder {
  protected abstract lTags: LoggerTagsFn
  protected async getOrCreateVideoChannelFromVideoObject () {
-    const channel = this.videoObject.attributedTo.find(a => a.type === 'Group')
+    const channel = await findOwner(this.videoObject.id, this.videoObject.attributedTo, 'Group')
    if (!channel) throw new Error('Cannot find associated video channel to video ' + this.videoObject.url)
-    if (checkUrlsSameHost(channel.id, this.videoObject.id) !== true) {
-      throw new Error(`Video channel url ${channel.id} does not have the same host than video object id ${this.videoObject.id}`)
-    }
    return getOrCreateAPActor(channel.id, 'all')
  }
-  protected tryToGenerateThumbnail (video: MVideoThumbnail): Promise<MThumbnail> {
+  protected async setThumbnail (video: MVideoThumbnail, t?: Transaction) {
-    return updateVideoMiniatureFromUrl({
+    const miniatureIcon = getThumbnailFromIcons(this.videoObject)
-      downloadUrl: getThumbnailFromIcons(this.videoObject).url,
+    if (!miniatureIcon) {
-      video,
+      logger.warn('Cannot find thumbnail in video object', { object: this.videoObject })
-      type: ThumbnailType.MINIATURE
-    }).catch(err => {
-      logger.warn('Cannot generate thumbnail of %s.', this.videoObject.id, { err, ...this.lTags() })
      return undefined
+    }
+    const miniatureModel = updateRemoteVideoThumbnail({
+      fileUrl: miniatureIcon.url,
+      video,
+      type: ThumbnailType.MINIATURE,
+      size: miniatureIcon,
+      onDisk: false // Lazy download remote thumbnails
    })
+    await video.addAndSaveThumbnail(miniatureModel, t)
  }
  protected async setPreview (video: MVideoFullLight, t?: Transaction) {
-    // Don't fetch the preview that could be big, create a placeholder instead
    const previewIcon = getPreviewFromIcons(this.videoObject)
    if (!previewIcon) return
-    const previewModel = updatePlaceholderThumbnail({
+    const previewModel = updateRemoteVideoThumbnail({
      fileUrl: previewIcon.url,
      video,
      type: ThumbnailType.PREVIEW,
-      size: previewIcon
+      size: previewIcon,
+      onDisk: false // Lazy download remote previews
    })
    await video.addAndSaveThumbnail(previewModel, t)
@@ -107,6 +109,16 @@ export abstract class APVideoAbstractBuilder {
    }
  }
+  protected async insertOrReplaceStoryboard (video: MVideoFullLight, t: Transaction) {
+    const existingStoryboard = await StoryboardModel.loadByVideo(video.id, t)
+    if (existingStoryboard) await existingStoryboard.destroy({ transaction: t })
+    const storyboardAttributes = getStoryboardAttributeFromObject(video, this.videoObject)
+    if (!storyboardAttributes) return
+    return StoryboardModel.create(storyboardAttributes, { transaction: t })
+  }
  protected async insertOrReplaceLive (video: MVideoFullLight, transaction: Transaction) {
    const attributes = getLiveAttributesFromObject(video, this.videoObject)
    const [ videoLive ] = await VideoLiveModel.upsert(attributes, { transaction, returning: true })
@@ -114,7 +126,7 @@ export abstract class APVideoAbstractBuilder {
    video.VideoLive = videoLive
  }
-  protected async setWebTorrentFiles (video: MVideoFullLight, t: Transaction) {
+  protected async setWebVideoFiles (video: MVideoFullLight, t: Transaction) {
    const videoFileAttributes = getFileAttributesFromUrl(video, this.videoObject.url)
    const newVideoFiles = videoFileAttributes.map(a => new VideoFileModel(a))
diff --git a/server/lib/activitypub/videos/shared/creator.ts b/server/lib/activitypub/videos/shared/creator.ts
index 77321d8a5..bc139e4fa 100644
--- a/server/lib/activitypub/videos/shared/creator.ts
+++ b/server/lib/activitypub/videos/shared/creator.ts
@@ -4,7 +4,7 @@ import { sequelizeTypescript } from '@server/initializers/database'
 import { Hooks } from '@server/lib/plugins/hooks'
 import { autoBlacklistVideoIfNeeded } from '@server/lib/video-blacklist'
 import { VideoModel } from '@server/models/video/video'
-import { MThumbnail, MVideoFullLight, MVideoThumbnail } from '@server/types/models'
+import { MVideoFullLight, MVideoThumbnail } from '@server/types/models'
 import { VideoObject } from '@shared/models'
 import { APVideoAbstractBuilder } from './abstract-builder'
 import { getVideoAttributesFromObject } from './object-to-model-attributes'
@@ -27,64 +27,38 @@ export class APVideoCreator extends APVideoAbstractBuilder {
    const videoData = getVideoAttributesFromObject(channel, this.videoObject, this.videoObject.to)
    const video = VideoModel.build({ ...videoData, likes: 0, dislikes: 0 }) as MVideoThumbnail
-    const promiseThumbnail = this.tryToGenerateThumbnail(video)
-    let thumbnailModel: MThumbnail
-    if (waitThumbnail === true) {
-      thumbnailModel = await promiseThumbnail
-    }
    const { autoBlacklisted, videoCreated } = await sequelizeTypescript.transaction(async t => {
-      try {
+      const videoCreated = await video.save({ transaction: t }) as MVideoFullLight
-        const videoCreated = await video.save({ transaction: t }) as MVideoFullLight
+      videoCreated.VideoChannel = channel
-        videoCreated.VideoChannel = channel
+      await this.setThumbnail(videoCreated, t)
-        if (thumbnailModel) await videoCreated.addAndSaveThumbnail(thumbnailModel, t)
+      await this.setPreview(videoCreated, t)
+      await this.setWebVideoFiles(videoCreated, t)
-        await this.setPreview(videoCreated, t)
+      await this.setStreamingPlaylists(videoCreated, t)
-        await this.setWebTorrentFiles(videoCreated, t)
+      await this.setTags(videoCreated, t)
-        await this.setStreamingPlaylists(videoCreated, t)
+      await this.setTrackers(videoCreated, t)
-        await this.setTags(videoCreated, t)
+      await this.insertOrReplaceCaptions(videoCreated, t)
-        await this.setTrackers(videoCreated, t)
+      await this.insertOrReplaceLive(videoCreated, t)
-        await this.insertOrReplaceCaptions(videoCreated, t)
+      await this.insertOrReplaceStoryboard(videoCreated, t)
-        await this.insertOrReplaceLive(videoCreated, t)
+      // We added a video in this channel, set it as updated
-        // We added a video in this channel, set it as updated
+      await channel.setAsUpdated(t)
-        await channel.setAsUpdated(t)
+      const autoBlacklisted = await autoBlacklistVideoIfNeeded({
-        const autoBlacklisted = await autoBlacklistVideoIfNeeded({
+        video: videoCreated,
-          video: videoCreated,
+        user: undefined,
-          user: undefined,
+        isRemote: true,
-          isRemote: true,
+        isNew: true,
-          isNew: true,
+        transaction: t
-          transaction: t
+      })
-        })
-        logger.info('Remote video with uuid %s inserted.', this.videoObject.uuid, this.lTags())
-        Hooks.runAction('action:activity-pub.remote-video.created', { video: videoCreated, videoAPObject: this.videoObject })
+      logger.info('Remote video with uuid %s inserted.', this.videoObject.uuid, this.lTags())
-        return { autoBlacklisted, videoCreated }
+      Hooks.runAction('action:activity-pub.remote-video.created', { video: videoCreated, videoAPObject: this.videoObject })
-      } catch (err) {
-        // FIXME: Use rollback hook when https://github.com/sequelize/sequelize/pull/13038 is released
-        if (thumbnailModel) await thumbnailModel.removeThumbnail()
-        throw err
+      return { autoBlacklisted, videoCreated }
-      }
    })
-    if (waitThumbnail === false) {
-      // Error is already caught above
-      // eslint-disable-next-line @typescript-eslint/no-floating-promises
-      promiseThumbnail.then(thumbnailModel => {
-        if (!thumbnailModel) return
-        thumbnailModel = videoCreated.id
-        return thumbnailModel.save()
-      })
-    }
    return { autoBlacklisted, videoCreated }
  }
 }
diff --git a/server/lib/activitypub/videos/shared/object-to-model-attributes.ts b/server/lib/activitypub/videos/shared/object-to-model-attributes.ts
index 8fd0a816c..a9e0bed97 100644
--- a/server/lib/activitypub/videos/shared/object-to-model-attributes.ts
+++ b/server/lib/activitypub/videos/shared/object-to-model-attributes.ts
@@ -1,6 +1,6 @@
 import { maxBy, minBy } from 'lodash'
 import { decode as magnetUriDecode } from 'magnet-uri'
-import { basename } from 'path'
+import { basename, extname } from 'path'
 import { isAPVideoFileUrlMetadataObject } from '@server/helpers/custom-validators/activitypub/videos'
 import { isVideoFileInfoHashValid } from '@server/helpers/custom-validators/videos'
 import { logger } from '@server/helpers/logger'
@@ -25,6 +25,9 @@ import {
  VideoStreamingPlaylistType
 } from '@shared/models'
 import { getDurationFromActivityStream } from '../../activity'
+import { isArray } from '@server/helpers/custom-validators/misc'
+import { generateImageFilename } from '@server/helpers/image-utils'
+import { arrayify } from '@shared/core-utils'
 function getThumbnailFromIcons (videoObject: VideoObject) {
  let validIcons = videoObject.icon.filter(i => i.width > THUMBNAILS_SIZE.minWidth)
@@ -166,6 +169,26 @@ function getCaptionAttributesFromObject (video: MVideoId, videoObject: VideoObje
  }))
 }
+function getStoryboardAttributeFromObject (video: MVideoId, videoObject: VideoObject) {
+  if (!isArray(videoObject.preview)) return undefined
+  const storyboard = videoObject.preview.find(p => p.rel.includes('storyboard'))
+  if (!storyboard) return undefined
+  const url = arrayify(storyboard.url).find(u => u.mediaType === 'image/jpeg')
+  return {
+    filename: generateImageFilename(extname(url.href)),
+    totalHeight: url.height,
+    totalWidth: url.width,
+    spriteHeight: url.tileHeight,
+    spriteWidth: url.tileWidth,
+    spriteDuration: getDurationFromActivityStream(url.tileDuration),
+    fileUrl: url.href,
+    videoId: video.id
+  }
+}
 function getVideoAttributesFromObject (videoChannel: MChannelId, videoObject: VideoObject, to: string[] = []) {
  const privacy = to.includes(ACTIVITY_PUB.PUBLIC)
    ? VideoPrivacy.PUBLIC
@@ -228,6 +251,7 @@ export {
  getLiveAttributesFromObject,
  getCaptionAttributesFromObject,
+  getStoryboardAttributeFromObject,
  getVideoAttributesFromObject
 }
diff --git a/server/lib/activitypub/videos/updater.ts b/server/lib/activitypub/videos/updater.ts
index 6ddd2301b..522d7b043 100644
--- a/server/lib/activitypub/videos/updater.ts
+++ b/server/lib/activitypub/videos/updater.ts
@@ -41,7 +41,7 @@ export class APVideoUpdater extends APVideoAbstractBuilder {
    try {
      const channelActor = await this.getOrCreateVideoChannelFromVideoObject()
-      const thumbnailModel = await this.tryToGenerateThumbnail(this.video)
+      const thumbnailModel = await this.setThumbnail(this.video)
      this.checkChannelUpdateOrThrow(channelActor)
@@ -50,15 +50,21 @@ export class APVideoUpdater extends APVideoAbstractBuilder {
      if (thumbnailModel) await videoUpdated.addAndSaveThumbnail(thumbnailModel)
      await runInReadCommittedTransaction(async t => {
-        await this.setWebTorrentFiles(videoUpdated, t)
+        await this.setWebVideoFiles(videoUpdated, t)
        await this.setStreamingPlaylists(videoUpdated, t)
      })
      await Promise.all([
        runInReadCommittedTransaction(t => this.setTags(videoUpdated, t)),
        runInReadCommittedTransaction(t => this.setTrackers(videoUpdated, t)),
-        this.setOrDeleteLive(videoUpdated),
+        runInReadCommittedTransaction(t => this.setStoryboard(videoUpdated, t)),
-        this.setPreview(videoUpdated)
+        runInReadCommittedTransaction(t => {
+          return Promise.all([
+            this.setPreview(videoUpdated, t),
+            this.setThumbnail(videoUpdated, t)
+          ])
+        }),
+        this.setOrDeleteLive(videoUpdated)
      ])
      await runInReadCommittedTransaction(t => this.setCaptions(videoUpdated, t))
@@ -138,6 +144,10 @@ export class APVideoUpdater extends APVideoAbstractBuilder {
    await this.insertOrReplaceCaptions(videoUpdated, t)
  }
+  private async setStoryboard (videoUpdated: MVideoFullLight, t: Transaction) {
+    await this.insertOrReplaceStoryboard(videoUpdated, t)
+  }
  private async setOrDeleteLive (videoUpdated: MVideoFullLight, transaction?: Transaction) {
    if (!this.video.isLive) return
diff --git a/server/lib/client-html.ts b/server/lib/client-html.ts
index 18b16bee1..be6df1792 100644
--- a/server/lib/client-html.ts
+++ b/server/lib/client-html.ts
@@ -32,6 +32,7 @@ import { getActivityStreamDuration } from './activitypub/activity'
 import { getBiggestActorImage } from './actor-image'
 import { Hooks } from './plugins/hooks'
 import { ServerConfigManager } from './server-config-manager'
+import { isVideoInPrivateDirectory } from './video-privacy'
 type Tags = {
  ogType: string
@@ -106,7 +107,7 @@ class ClientHtml {
    ])
    // Let Angular application handle errors
-    if (!video || video.privacy === VideoPrivacy.PRIVATE || video.privacy === VideoPrivacy.INTERNAL || video.VideoBlacklist) {
+    if (!video || isVideoInPrivateDirectory(video.privacy) || video.VideoBlacklist) {
      res.status(HttpStatusCode.NOT_FOUND_404)
      return html
    }
diff --git a/server/lib/files-cache/avatar-permanent-file-cache.ts b/server/lib/files-cache/avatar-permanent-file-cache.ts
new file mode 100644
index 000000000..0c508b063
--- /dev/null
+++ b/server/lib/files-cache/avatar-permanent-file-cache.ts
@@ -0,0 +1,27 @@
+import { CONFIG } from '@server/initializers/config'
+import { ACTOR_IMAGES_SIZE } from '@server/initializers/constants'
+import { ActorImageModel } from '@server/models/actor/actor-image'
+import { MActorImage } from '@server/types/models'
+import { AbstractPermanentFileCache } from './shared'
+export class AvatarPermanentFileCache extends AbstractPermanentFileCache<MActorImage> {
+  constructor () {
+    super(CONFIG.STORAGE.ACTOR_IMAGES_DIR)
+  }
+  protected loadModel (filename: string) {
+    return ActorImageModel.loadByName(filename)
+  }
+  protected getImageSize (image: MActorImage): { width: number, height: number } {
+    if (image.width && image.height) {
+      return {
+        height: image.height,
+        width: image.width
+      }
+    }
+    return ACTOR_IMAGES_SIZE[image.type][0]
+  }
+}
diff --git a/server/lib/files-cache/index.ts b/server/lib/files-cache/index.ts
index e5853f7d6..5630a9b80 100644
--- a/server/lib/files-cache/index.ts
+++ b/server/lib/files-cache/index.ts
@@ -1,3 +1,6 @@
-export * from './videos-preview-cache'
+export * from './avatar-permanent-file-cache'
-export * from './videos-caption-cache'
+export * from './video-miniature-permanent-file-cache'
-export * from './videos-torrent-cache'
+export * from './video-captions-simple-file-cache'
+export * from './video-previews-simple-file-cache'
+export * from './video-storyboards-simple-file-cache'
+export * from './video-torrents-simple-file-cache'
diff --git a/server/lib/files-cache/shared/abstract-permanent-file-cache.ts b/server/lib/files-cache/shared/abstract-permanent-file-cache.ts
new file mode 100644
index 000000000..f990e9872
--- /dev/null
+++ b/server/lib/files-cache/shared/abstract-permanent-file-cache.ts
@@ -0,0 +1,132 @@
+import express from 'express'
+import { LRUCache } from 'lru-cache'
+import { Model } from 'sequelize'
+import { logger } from '@server/helpers/logger'
+import { CachePromise } from '@server/helpers/promise-cache'
+import { LRU_CACHE, STATIC_MAX_AGE } from '@server/initializers/constants'
+import { downloadImageFromWorker } from '@server/lib/worker/parent-process'
+import { HttpStatusCode } from '@shared/models'
+type ImageModel = {
+  fileUrl: string
+  filename: string
+  onDisk: boolean
+  isOwned (): boolean
+  getPath (): string
+  save (): Promise<Model>
+}
+export abstract class AbstractPermanentFileCache <M extends ImageModel> {
+  // Unsafe because it can return paths that do not exist anymore
+  private readonly filenameToPathUnsafeCache = new LRUCache<string, string>({
+    max: LRU_CACHE.FILENAME_TO_PATH_PERMANENT_FILE_CACHE.MAX_SIZE
+  })
+  protected abstract getImageSize (image: M): { width: number, height: number }
+  protected abstract loadModel (filename: string): Promise<M>
+  constructor (private readonly directory: string) {
+  }
+  async lazyServe (options: {
+    filename: string
+    res: express.Response
+    next: express.NextFunction
+  }) {
+    const { filename, res, next } = options
+    if (this.filenameToPathUnsafeCache.has(filename)) {
+      return res.sendFile(this.filenameToPathUnsafeCache.get(filename), { maxAge: STATIC_MAX_AGE.SERVER })
+    }
+    const image = await this.lazyLoadIfNeeded(filename)
+    if (!image) return res.status(HttpStatusCode.NOT_FOUND_404).end()
+    const path = image.getPath()
+    this.filenameToPathUnsafeCache.set(filename, path)
+    return res.sendFile(path, { maxAge: STATIC_MAX_AGE.LAZY_SERVER }, (err: any) => {
+      if (!err) return
+      this.onServeError({ err, image, next, filename })
+    })
+  }
+  @CachePromise({
+    keyBuilder: filename => filename
+  })
+  private async lazyLoadIfNeeded (filename: string) {
+    const image = await this.loadModel(filename)
+    if (!image) return undefined
+    if (image.onDisk === false) {
+      if (!image.fileUrl) return undefined
+      try {
+        await this.downloadRemoteFile(image)
+      } catch (err) {
+        logger.warn('Cannot process remote image %s.', image.fileUrl, { err })
+        return undefined
+      }
+    }
+    return image
+  }
+  async downloadRemoteFile (image: M) {
+    logger.info('Download remote image %s lazily.', image.fileUrl)
+    const destination = await this.downloadImage({
+      filename: image.filename,
+      fileUrl: image.fileUrl,
+      size: this.getImageSize(image)
+    })
+    image.onDisk = true
+    image.save()
+      .catch(err => logger.error('Cannot save new image disk state.', { err }))
+    return destination
+  }
+  private onServeError (options: {
+    err: any
+    image: M
+    filename: string
+    next: express.NextFunction
+  }) {
+    const { err, image, filename, next } = options
+    // It seems this actor image is not on the disk anymore
+    if (err.status === HttpStatusCode.NOT_FOUND_404 && !image.isOwned()) {
+      logger.error('Cannot lazy serve image %s.', filename, { err })
+      this.filenameToPathUnsafeCache.delete(filename)
+      image.onDisk = false
+      image.save()
+        .catch(err => logger.error('Cannot save new image disk state.', { err }))
+    }
+    return next(err)
+  }
+  private downloadImage (options: {
+    fileUrl: string
+    filename: string
+    size: { width: number, height: number }
+  }) {
+    const downloaderOptions = {
+      url: options.fileUrl,
+      destDir: this.directory,
+      destName: options.filename,
+      size: options.size
+    }
+    return downloadImageFromWorker(downloaderOptions)
+  }
+}
diff --git a/server/lib/files-cache/abstract-video-static-file-cache.ts b/server/lib/files-cache/shared/abstract-simple-file-cache.ts
index a7ac88525..6fab322cd 100644
--- a/server/lib/files-cache/abstract-video-static-file-cache.ts
+++ b/server/lib/files-cache/shared/abstract-simple-file-cache.ts
@@ -1,10 +1,10 @@
 import { remove } from 'fs-extra'
-import { logger } from '../../helpers/logger'
+import { logger } from '../../../helpers/logger'
 import memoizee from 'memoizee'
 type GetFilePathResult = { isOwned: boolean, path: string, downloadName?: string } | undefined
-export abstract class AbstractVideoStaticFileCache <T> {
+export abstract class AbstractSimpleFileCache <T> {
  getFilePath: (params: T) => Promise<GetFilePathResult>
diff --git a/server/lib/files-cache/shared/index.ts b/server/lib/files-cache/shared/index.ts
new file mode 100644
index 000000000..61c4aacc7
--- /dev/null
+++ b/server/lib/files-cache/shared/index.ts
@@ -0,0 +1,2 @@
+export * from './abstract-permanent-file-cache'
+export * from './abstract-simple-file-cache'
diff --git a/server/lib/files-cache/videos-caption-cache.ts b/server/lib/files-cache/video-captions-simple-file-cache.ts
index d21acf4ef..cbeeff732 100644
--- a/server/lib/files-cache/videos-caption-cache.ts
+++ b/server/lib/files-cache/video-captions-simple-file-cache.ts
@@ -5,11 +5,11 @@ import { CONFIG } from '../../initializers/config'
 import { FILES_CACHE } from '../../initializers/constants'
 import { VideoModel } from '../../models/video/video'
 import { VideoCaptionModel } from '../../models/video/video-caption'
-import { AbstractVideoStaticFileCache } from './abstract-video-static-file-cache'
+import { AbstractSimpleFileCache } from './shared/abstract-simple-file-cache'
-class VideosCaptionCache extends AbstractVideoStaticFileCache <string> {
+class VideoCaptionsSimpleFileCache extends AbstractSimpleFileCache <string> {
-  private static instance: VideosCaptionCache
+  private static instance: VideoCaptionsSimpleFileCache
  private constructor () {
    super()
@@ -23,7 +23,9 @@ class VideosCaptionCache extends AbstractVideoStaticFileCache <string> {
    const videoCaption = await VideoCaptionModel.loadWithVideoByFilename(filename)
    if (!videoCaption) return undefined
-    if (videoCaption.isOwned()) return { isOwned: true, path: join(CONFIG.STORAGE.CAPTIONS_DIR, videoCaption.filename) }
+    if (videoCaption.isOwned()) {
+      return { isOwned: true, path: join(CONFIG.STORAGE.CAPTIONS_DIR, videoCaption.filename) }
+    }
    return this.loadRemoteFile(filename)
  }
@@ -55,5 +57,5 @@ class VideosCaptionCache extends AbstractVideoStaticFileCache <string> {
 }
 export {
-  VideosCaptionCache
+  VideoCaptionsSimpleFileCache
 }
diff --git a/server/lib/files-cache/video-miniature-permanent-file-cache.ts b/server/lib/files-cache/video-miniature-permanent-file-cache.ts
new file mode 100644
index 000000000..35d9466f7
--- /dev/null
+++ b/server/lib/files-cache/video-miniature-permanent-file-cache.ts
@@ -0,0 +1,28 @@
+import { CONFIG } from '@server/initializers/config'
+import { THUMBNAILS_SIZE } from '@server/initializers/constants'
+import { ThumbnailModel } from '@server/models/video/thumbnail'
+import { MThumbnail } from '@server/types/models'
+import { ThumbnailType } from '@shared/models'
+import { AbstractPermanentFileCache } from './shared'
+export class VideoMiniaturePermanentFileCache extends AbstractPermanentFileCache<MThumbnail> {
+  constructor () {
+    super(CONFIG.STORAGE.THUMBNAILS_DIR)
+  }
+  protected loadModel (filename: string) {
+    return ThumbnailModel.loadByFilename(filename, ThumbnailType.MINIATURE)
+  }
+  protected getImageSize (image: MThumbnail): { width: number, height: number } {
+    if (image.width && image.height) {
+      return {
+        height: image.height,
+        width: image.width
+      }
+    }
+    return THUMBNAILS_SIZE
+  }
+}
diff --git a/server/lib/files-cache/videos-preview-cache.ts b/server/lib/files-cache/video-previews-simple-file-cache.ts
index d19c3f4f4..a05e80e16 100644
--- a/server/lib/files-cache/videos-preview-cache.ts
+++ b/server/lib/files-cache/video-previews-simple-file-cache.ts
@@ -1,15 +1,15 @@
 import { join } from 'path'
 import { FILES_CACHE } from '../../initializers/constants'
 import { VideoModel } from '../../models/video/video'
-import { AbstractVideoStaticFileCache } from './abstract-video-static-file-cache'
+import { AbstractSimpleFileCache } from './shared/abstract-simple-file-cache'
 import { doRequestAndSaveToFile } from '@server/helpers/requests'
 import { ThumbnailModel } from '@server/models/video/thumbnail'
 import { ThumbnailType } from '@shared/models'
 import { logger } from '@server/helpers/logger'
-class VideosPreviewCache extends AbstractVideoStaticFileCache <string> {
+class VideoPreviewsSimpleFileCache extends AbstractSimpleFileCache <string> {
-  private static instance: VideosPreviewCache
+  private static instance: VideoPreviewsSimpleFileCache
  private constructor () {
    super()
@@ -54,5 +54,5 @@ class VideosPreviewCache extends AbstractVideoStaticFileCache <string> {
 }
 export {
-  VideosPreviewCache
+  VideoPreviewsSimpleFileCache
 }
diff --git a/server/lib/files-cache/video-storyboards-simple-file-cache.ts b/server/lib/files-cache/video-storyboards-simple-file-cache.ts
new file mode 100644
index 000000000..4cd96e70c
--- /dev/null
+++ b/server/lib/files-cache/video-storyboards-simple-file-cache.ts
@@ -0,0 +1,53 @@
+import { join } from 'path'
+import { logger } from '@server/helpers/logger'
+import { doRequestAndSaveToFile } from '@server/helpers/requests'
+import { StoryboardModel } from '@server/models/video/storyboard'
+import { FILES_CACHE } from '../../initializers/constants'
+import { AbstractSimpleFileCache } from './shared/abstract-simple-file-cache'
+class VideoStoryboardsSimpleFileCache extends AbstractSimpleFileCache <string> {
+  private static instance: VideoStoryboardsSimpleFileCache
+  private constructor () {
+    super()
+  }
+  static get Instance () {
+    return this.instance || (this.instance = new this())
+  }
+  async getFilePathImpl (filename: string) {
+    const storyboard = await StoryboardModel.loadWithVideoByFilename(filename)
+    if (!storyboard) return undefined
+    if (storyboard.Video.isOwned()) return { isOwned: true, path: storyboard.getPath() }
+    return this.loadRemoteFile(storyboard.filename)
+  }
+  // Key is the storyboard filename
+  protected async loadRemoteFile (key: string) {
+    const storyboard = await StoryboardModel.loadWithVideoByFilename(key)
+    if (!storyboard) return undefined
+    const destPath = join(FILES_CACHE.STORYBOARDS.DIRECTORY, storyboard.filename)
+    const remoteUrl = storyboard.getOriginFileUrl(storyboard.Video)
+    try {
+      await doRequestAndSaveToFile(remoteUrl, destPath)
+      logger.debug('Fetched remote storyboard %s to %s.', remoteUrl, destPath)
+      return { isOwned: false, path: destPath }
+    } catch (err) {
+      logger.info('Cannot fetch remote storyboard file %s.', remoteUrl, { err })
+      return undefined
+    }
+  }
+}
+export {
+  VideoStoryboardsSimpleFileCache
+}
diff --git a/server/lib/files-cache/videos-torrent-cache.ts b/server/lib/files-cache/video-torrents-simple-file-cache.ts
index a6bf98dd4..8bcd0b9bf 100644
--- a/server/lib/files-cache/videos-torrent-cache.ts
+++ b/server/lib/files-cache/video-torrents-simple-file-cache.ts
@@ -6,11 +6,11 @@ import { MVideo, MVideoFile } from '@server/types/models'
 import { CONFIG } from '../../initializers/config'
 import { FILES_CACHE } from '../../initializers/constants'
 import { VideoModel } from '../../models/video/video'
-import { AbstractVideoStaticFileCache } from './abstract-video-static-file-cache'
+import { AbstractSimpleFileCache } from './shared/abstract-simple-file-cache'
-class VideosTorrentCache extends AbstractVideoStaticFileCache <string> {
+class VideoTorrentsSimpleFileCache extends AbstractSimpleFileCache <string> {
-  private static instance: VideosTorrentCache
+  private static instance: VideoTorrentsSimpleFileCache
  private constructor () {
    super()
@@ -66,5 +66,5 @@ class VideosTorrentCache extends AbstractVideoStaticFileCache <string> {
 }
 export {
-  VideosTorrentCache
+  VideoTorrentsSimpleFileCache
 }
diff --git a/server/lib/hls.ts b/server/lib/hls.ts
index fc1d7e1b0..19044d7c2 100644
--- a/server/lib/hls.ts
+++ b/server/lib/hls.ts
@@ -8,7 +8,7 @@ import { sha256 } from '@shared/extra-utils'
 import { getVideoStreamDimensionsInfo } from '@shared/ffmpeg'
 import { VideoStorage } from '@shared/models'
 import { getAudioStreamCodec, getVideoStreamCodec } from '../helpers/ffmpeg'
-import { logger } from '../helpers/logger'
+import { logger, loggerTagsFactory } from '../helpers/logger'
 import { doRequest, doRequestAndSaveToFile } from '../helpers/requests'
 import { generateRandomString } from '../helpers/utils'
 import { CONFIG } from '../initializers/config'
@@ -20,6 +20,8 @@ import { storeHLSFileFromFilename } from './object-storage'
 import { generateHLSMasterPlaylistFilename, generateHlsSha256SegmentsFilename, getHlsResolutionPlaylistFilename } from './paths'
 import { VideoPathManager } from './video-path-manager'
+const lTags = loggerTagsFactory('hls')
 async function updateStreamingPlaylistsInfohashesIfNeeded () {
  const playlistsToUpdate = await VideoStreamingPlaylistModel.listByIncorrectPeerVersion()
@@ -48,7 +50,7 @@ async function updatePlaylistAfterFileChange (video: MVideo, playlist: MStreamin
    video.setHLSPlaylist(playlistWithFiles)
  } catch (err) {
-    logger.info('Cannot update playlist after file change. Maybe due to concurrent transcoding', { err })
+    logger.warn('Cannot update playlist after file change. Maybe due to concurrent transcoding', { err })
  }
 }
@@ -95,6 +97,8 @@ function updateMasterHLSPlaylist (video: MVideo, playlistArg: MStreamingPlaylist
    const masterPlaylistPath = VideoPathManager.Instance.getFSHLSOutputPath(video, playlist.playlistFilename)
    await writeFile(masterPlaylistPath, masterPlaylists.join('\n') + '\n')
+    logger.info('Updating %s master playlist file of video %s', masterPlaylistPath, video.uuid, lTags(video.uuid))
    if (playlist.storage === VideoStorage.OBJECT_STORAGE) {
      playlist.playlistUrl = await storeHLSFileFromFilename(playlist, playlist.playlistFilename)
      await remove(masterPlaylistPath)
diff --git a/server/lib/job-queue/handlers/generate-storyboard.ts b/server/lib/job-queue/handlers/generate-storyboard.ts
new file mode 100644
index 000000000..ec07c568c
--- /dev/null
+++ b/server/lib/job-queue/handlers/generate-storyboard.ts
@@ -0,0 +1,149 @@
+import { Job } from 'bullmq'
+import { join } from 'path'
+import { getFFmpegCommandWrapperOptions } from '@server/helpers/ffmpeg'
+import { generateImageFilename, getImageSize } from '@server/helpers/image-utils'
+import { logger, loggerTagsFactory } from '@server/helpers/logger'
+import { CONFIG } from '@server/initializers/config'
+import { STORYBOARD } from '@server/initializers/constants'
+import { federateVideoIfNeeded } from '@server/lib/activitypub/videos'
+import { VideoPathManager } from '@server/lib/video-path-manager'
+import { StoryboardModel } from '@server/models/video/storyboard'
+import { VideoModel } from '@server/models/video/video'
+import { MVideo } from '@server/types/models'
+import { FFmpegImage, isAudioFile } from '@shared/ffmpeg'
+import { GenerateStoryboardPayload } from '@shared/models'
+const lTagsBase = loggerTagsFactory('storyboard')
+async function processGenerateStoryboard (job: Job): Promise<void> {
+  const payload = job.data as GenerateStoryboardPayload
+  const lTags = lTagsBase(payload.videoUUID)
+  logger.info('Processing generate storyboard of %s in job %s.', payload.videoUUID, job.id, lTags)
+  const inputFileMutexReleaser = await VideoPathManager.Instance.lockFiles(payload.videoUUID)
+  try {
+    const video = await VideoModel.loadFull(payload.videoUUID)
+    if (!video) {
+      logger.info('Video %s does not exist anymore, skipping storyboard generation.', payload.videoUUID, lTags)
+      return
+    }
+    const inputFile = video.getMaxQualityFile()
+    await VideoPathManager.Instance.makeAvailableVideoFile(inputFile, async videoPath => {
+      const isAudio = await isAudioFile(videoPath)
+      if (isAudio) {
+        logger.info('Do not generate a storyboard of %s since the video does not have a video stream', payload.videoUUID, lTags)
+        return
+      }
+      const ffmpeg = new FFmpegImage(getFFmpegCommandWrapperOptions('thumbnail'))
+      const filename = generateImageFilename()
+      const destination = join(CONFIG.STORAGE.STORYBOARDS_DIR, filename)
+      const totalSprites = buildTotalSprites(video)
+      if (totalSprites === 0) {
+        logger.info('Do not generate a storyboard of %s because the video is not long enough', payload.videoUUID, lTags)
+        return
+      }
+      const spriteDuration = Math.round(video.duration / totalSprites)
+      const spritesCount = findGridSize({
+        toFind: totalSprites,
+        maxEdgeCount: STORYBOARD.SPRITES_MAX_EDGE_COUNT
+      })
+      logger.debug(
+        'Generating storyboard from video of %s to %s', video.uuid, destination,
+        { ...lTags, spritesCount, spriteDuration, videoDuration: video.duration }
+      )
+      await ffmpeg.generateStoryboardFromVideo({
+        destination,
+        path: videoPath,
+        sprites: {
+          size: STORYBOARD.SPRITE_SIZE,
+          count: spritesCount,
+          duration: spriteDuration
+        }
+      })
+      const imageSize = await getImageSize(destination)
+      const existing = await StoryboardModel.loadByVideo(video.id)
+      if (existing) await existing.destroy()
+      await StoryboardModel.create({
+        filename,
+        totalHeight: imageSize.height,
+        totalWidth: imageSize.width,
+        spriteHeight: STORYBOARD.SPRITE_SIZE.height,
+        spriteWidth: STORYBOARD.SPRITE_SIZE.width,
+        spriteDuration,
+        videoId: video.id
+      })
+      logger.info('Storyboard generation %s ended for video %s.', destination, video.uuid, lTags)
+    })
+    if (payload.federate) {
+      await federateVideoIfNeeded(video, false)
+    }
+  } finally {
+    inputFileMutexReleaser()
+  }
+}
+// ---------------------------------------------------------------------------
+export {
+  processGenerateStoryboard
+}
+function buildTotalSprites (video: MVideo) {
+  const maxSprites = STORYBOARD.SPRITE_SIZE.height * STORYBOARD.SPRITE_SIZE.width
+  const totalSprites = Math.min(Math.ceil(video.duration), maxSprites)
+  // We can generate a single line
+  if (totalSprites <= STORYBOARD.SPRITES_MAX_EDGE_COUNT) return totalSprites
+  return findGridFit(totalSprites, STORYBOARD.SPRITES_MAX_EDGE_COUNT)
+}
+function findGridSize (options: {
+  toFind: number
+  maxEdgeCount: number
+}) {
+  const { toFind, maxEdgeCount } = options
+  for (let i = 1; i <= maxEdgeCount; i++) {
+    for (let j = i; j <= maxEdgeCount; j++) {
+      if (toFind === i * j) return { width: j, height: i }
+    }
+  }
+  throw new Error(`Could not find grid size (to find: ${toFind}, max edge count: ${maxEdgeCount}`)
+}
+function findGridFit (value: number, maxMultiplier: number) {
+  for (let i = value; i--; i > 0) {
+    if (!isPrimeWithin(i, maxMultiplier)) return i
+  }
+  throw new Error('Could not find prime number below ' + value)
+}
+function isPrimeWithin (value: number, maxMultiplier: number) {
+  if (value < 2) return false
+  for (let i = 2, end = Math.min(Math.sqrt(value), maxMultiplier); i <= end; i++) {
+    if (value % i === 0 && value / i <= maxMultiplier) return false
+  }
+  return true
+}
diff --git a/server/lib/job-queue/handlers/move-to-object-storage.ts b/server/lib/job-queue/handlers/move-to-object-storage.ts
index 26752ff37..9a99b6722 100644
--- a/server/lib/job-queue/handlers/move-to-object-storage.ts
+++ b/server/lib/job-queue/handlers/move-to-object-storage.ts
@@ -4,7 +4,7 @@ import { join } from 'path'
 import { logger, loggerTagsFactory } from '@server/helpers/logger'
 import { updateTorrentMetadata } from '@server/helpers/webtorrent'
 import { P2P_MEDIA_LOADER_PEER_VERSION } from '@server/initializers/constants'
-import { storeHLSFileFromFilename, storeWebTorrentFile } from '@server/lib/object-storage'
+import { storeHLSFileFromFilename, storeWebVideoFile } from '@server/lib/object-storage'
 import { getHLSDirectory, getHlsResolutionPlaylistFilename } from '@server/lib/paths'
 import { VideoPathManager } from '@server/lib/video-path-manager'
 import { moveToFailedMoveToObjectStorageState, moveToNextState } from '@server/lib/video-state'
@@ -33,9 +33,9 @@ export async function processMoveToObjectStorage (job: Job) {
  try {
    if (video.VideoFiles) {
-      logger.debug('Moving %d webtorrent files for video %s.', video.VideoFiles.length, video.uuid, lTags)
+      logger.debug('Moving %d web video files for video %s.', video.VideoFiles.length, video.uuid, lTags)
-      await moveWebTorrentFiles(video)
+      await moveWebVideoFiles(video)
    }
    if (video.VideoStreamingPlaylists) {
@@ -75,11 +75,11 @@ export async function onMoveToObjectStorageFailure (job: Job, err: any) {
 // ---------------------------------------------------------------------------
-async function moveWebTorrentFiles (video: MVideoWithAllFiles) {
+async function moveWebVideoFiles (video: MVideoWithAllFiles) {
  for (const file of video.VideoFiles) {
    if (file.storage !== VideoStorage.FILE_SYSTEM) continue
-    const fileUrl = await storeWebTorrentFile(video, file)
+    const fileUrl = await storeWebVideoFile(video, file)
    const oldPath = VideoPathManager.Instance.getFSVideoFileOutputPath(video, file)
    await onFileMoved({ videoOrPlaylist: video, file, fileUrl, oldPath })
diff --git a/server/lib/job-queue/handlers/video-file-import.ts b/server/lib/job-queue/handlers/video-file-import.ts
index 9a4550e4d..d221e8968 100644
--- a/server/lib/job-queue/handlers/video-file-import.ts
+++ b/server/lib/job-queue/handlers/video-file-import.ts
@@ -3,7 +3,7 @@ import { copy, stat } from 'fs-extra'
 import { createTorrentAndSetInfoHash } from '@server/helpers/webtorrent'
 import { CONFIG } from '@server/initializers/config'
 import { federateVideoIfNeeded } from '@server/lib/activitypub/videos'
-import { generateWebTorrentVideoFilename } from '@server/lib/paths'
+import { generateWebVideoFilename } from '@server/lib/paths'
 import { buildMoveToObjectStorageJob } from '@server/lib/video'
 import { VideoPathManager } from '@server/lib/video-path-manager'
 import { VideoModel } from '@server/models/video/video'
@@ -56,7 +56,7 @@ async function updateVideoFile (video: MVideoFullLight, inputFilePath: string) {
  if (currentVideoFile) {
    // Remove old file and old torrent
-    await video.removeWebTorrentFile(currentVideoFile)
+    await video.removeWebVideoFile(currentVideoFile)
    // Remove the old video file from the array
    video.VideoFiles = video.VideoFiles.filter(f => f !== currentVideoFile)
@@ -66,7 +66,7 @@ async function updateVideoFile (video: MVideoFullLight, inputFilePath: string) {
  const newVideoFile = new VideoFileModel({
    resolution,
    extname: fileExt,
-    filename: generateWebTorrentVideoFilename(resolution, fileExt),
+    filename: generateWebVideoFilename(resolution, fileExt),
    storage: VideoStorage.FILE_SYSTEM,
    size,
    fps,
diff --git a/server/lib/job-queue/handlers/video-import.ts b/server/lib/job-queue/handlers/video-import.ts
index cdd362f6e..e5cd258d6 100644
--- a/server/lib/job-queue/handlers/video-import.ts
+++ b/server/lib/job-queue/handlers/video-import.ts
@@ -4,7 +4,7 @@ import { retryTransactionWrapper } from '@server/helpers/database-utils'
 import { YoutubeDLWrapper } from '@server/helpers/youtube-dl'
 import { CONFIG } from '@server/initializers/config'
 import { isPostImportVideoAccepted } from '@server/lib/moderation'
-import { generateWebTorrentVideoFilename } from '@server/lib/paths'
+import { generateWebVideoFilename } from '@server/lib/paths'
 import { Hooks } from '@server/lib/plugins/hooks'
 import { ServerConfigManager } from '@server/lib/server-config-manager'
 import { createOptimizeOrMergeAudioJobs } from '@server/lib/transcoding/create-transcoding-job'
@@ -39,7 +39,7 @@ import { VideoFileModel } from '../../../models/video/video-file'
 import { VideoImportModel } from '../../../models/video/video-import'
 import { federateVideoIfNeeded } from '../../activitypub/videos'
 import { Notifier } from '../../notifier'
-import { generateVideoMiniature } from '../../thumbnail'
+import { generateLocalVideoMiniature } from '../../thumbnail'
 import { JobQueue } from '../job-queue'
 async function processVideoImport (job: Job): Promise<VideoImportPreventExceptionResult> {
@@ -148,7 +148,7 @@ async function processFile (downloader: () => Promise<string>, videoImport: MVid
      extname: fileExt,
      resolution,
      size: stats.size,
-      filename: generateWebTorrentVideoFilename(resolution, fileExt),
+      filename: generateWebVideoFilename(resolution, fileExt),
      fps,
      videoId: videoImport.videoId
    }
@@ -274,7 +274,7 @@ async function generateMiniature (videoImportWithFiles: MVideoImportDefaultFiles
    }
  }
-  const miniatureModel = await generateVideoMiniature({
+  const miniatureModel = await generateLocalVideoMiniature({
    video: videoImportWithFiles.Video,
    videoFile,
    type: thumbnailType
@@ -306,6 +306,15 @@ async function afterImportSuccess (options: {
    Notifier.Instance.notifyOnNewVideoIfNeeded(video)
  }
+  // Generate the storyboard in the job queue, and don't forget to federate an update after
+  await JobQueue.Instance.createJob({
+    type: 'generate-video-storyboard' as 'generate-video-storyboard',
+    payload: {
+      videoUUID: video.uuid,
+      federate: true
+    }
+  })
  if (video.state === VideoState.TO_MOVE_TO_EXTERNAL_STORAGE) {
    await JobQueue.Instance.createJob(
      await buildMoveToObjectStorageJob({ video, previousVideoState: VideoState.TO_IMPORT })
diff --git a/server/lib/job-queue/handlers/video-live-ending.ts b/server/lib/job-queue/handlers/video-live-ending.ts
index 49feb53f2..ae886de35 100644
--- a/server/lib/job-queue/handlers/video-live-ending.ts
+++ b/server/lib/job-queue/handlers/video-live-ending.ts
@@ -1,11 +1,13 @@
 import { Job } from 'bullmq'
 import { readdir, remove } from 'fs-extra'
 import { join } from 'path'
+import { peertubeTruncate } from '@server/helpers/core-utils'
+import { CONSTRAINTS_FIELDS } from '@server/initializers/constants'
 import { getLocalVideoActivityPubUrl } from '@server/lib/activitypub/url'
 import { federateVideoIfNeeded } from '@server/lib/activitypub/videos'
 import { cleanupAndDestroyPermanentLive, cleanupTMPLiveFiles, cleanupUnsavedNormalLive } from '@server/lib/live'
 import { generateHLSMasterPlaylistFilename, generateHlsSha256SegmentsFilename, getLiveReplayBaseDirectory } from '@server/lib/paths'
-import { generateVideoMiniature } from '@server/lib/thumbnail'
+import { generateLocalVideoMiniature } from '@server/lib/thumbnail'
 import { generateHlsPlaylistResolutionFromTS } from '@server/lib/transcoding/hls-transcoding'
 import { VideoPathManager } from '@server/lib/video-path-manager'
 import { moveToNextState } from '@server/lib/video-state'
@@ -20,8 +22,7 @@ import { MVideo, MVideoLive, MVideoLiveSession, MVideoWithAllFiles } from '@serv
 import { ffprobePromise, getAudioStream, getVideoStreamDimensionsInfo, getVideoStreamFPS } from '@shared/ffmpeg'
 import { ThumbnailType, VideoLiveEndingPayload, VideoState } from '@shared/models'
 import { logger, loggerTagsFactory } from '../../../helpers/logger'
-import { peertubeTruncate } from '@server/helpers/core-utils'
+import { JobQueue } from '../job-queue'
-import { CONSTRAINTS_FIELDS } from '@server/initializers/constants'
 const lTags = loggerTagsFactory('live', 'job')
@@ -142,11 +143,13 @@ async function saveReplayToExternalVideo (options: {
  await remove(replayDirectory)
  for (const type of [ ThumbnailType.MINIATURE, ThumbnailType.PREVIEW ]) {
-    const image = await generateVideoMiniature({ video: replayVideo, videoFile: replayVideo.getMaxQualityFile(), type })
+    const image = await generateLocalVideoMiniature({ video: replayVideo, videoFile: replayVideo.getMaxQualityFile(), type })
    await replayVideo.addAndSaveThumbnail(image)
  }
  await moveToNextState({ video: replayVideo, isNewVideo: true })
+  await createStoryboardJob(replayVideo)
 }
 async function replaceLiveByReplay (options: {
@@ -186,6 +189,7 @@ async function replaceLiveByReplay (options: {
  await assignReplayFilesToVideo({ video: videoWithFiles, replayDirectory })
+  // FIXME: should not happen in this function
  if (permanentLive) { // Remove session replay
    await remove(replayDirectory)
  } else { // We won't stream again in this live, we can delete the base replay directory
@@ -194,7 +198,7 @@ async function replaceLiveByReplay (options: {
  // Regenerate the thumbnail & preview?
  if (videoWithFiles.getMiniature().automaticallyGenerated === true) {
-    const miniature = await generateVideoMiniature({
+    const miniature = await generateLocalVideoMiniature({
      video: videoWithFiles,
      videoFile: videoWithFiles.getMaxQualityFile(),
      type: ThumbnailType.MINIATURE
@@ -203,7 +207,7 @@ async function replaceLiveByReplay (options: {
  }
  if (videoWithFiles.getPreview().automaticallyGenerated === true) {
-    const preview = await generateVideoMiniature({
+    const preview = await generateLocalVideoMiniature({
      video: videoWithFiles,
      videoFile: videoWithFiles.getMaxQualityFile(),
      type: ThumbnailType.PREVIEW
@@ -213,6 +217,8 @@ async function replaceLiveByReplay (options: {
  // We consider this is a new video
  await moveToNextState({ video: videoWithFiles, isNewVideo: true })
+  await createStoryboardJob(videoWithFiles)
 }
 async function assignReplayFilesToVideo (options: {
@@ -277,3 +283,13 @@ async function cleanupLiveAndFederate (options: {
    logger.warn('Cannot federate live after cleanup', { videoId: video.id, err })
  }
 }
+function createStoryboardJob (video: MVideo) {
+  return JobQueue.Instance.createJob({
+    type: 'generate-video-storyboard' as 'generate-video-storyboard',
+    payload: {
+      videoUUID: video.uuid,
+      federate: true
+    }
+  })
+}
diff --git a/server/lib/job-queue/handlers/video-transcoding.ts b/server/lib/job-queue/handlers/video-transcoding.ts
index f8758f170..1c8f4fd9f 100644
--- a/server/lib/job-queue/handlers/video-transcoding.ts
+++ b/server/lib/job-queue/handlers/video-transcoding.ts
@@ -1,8 +1,8 @@
 import { Job } from 'bullmq'
 import { onTranscodingEnded } from '@server/lib/transcoding/ended-transcoding'
 import { generateHlsPlaylistResolution } from '@server/lib/transcoding/hls-transcoding'
-import { mergeAudioVideofile, optimizeOriginalVideofile, transcodeNewWebTorrentResolution } from '@server/lib/transcoding/web-transcoding'
+import { mergeAudioVideofile, optimizeOriginalVideofile, transcodeNewWebVideoResolution } from '@server/lib/transcoding/web-transcoding'
-import { removeAllWebTorrentFiles } from '@server/lib/video-file'
+import { removeAllWebVideoFiles } from '@server/lib/video-file'
 import { VideoPathManager } from '@server/lib/video-path-manager'
 import { moveToFailedTranscodingState } from '@server/lib/video-state'
 import { UserModel } from '@server/models/user/user'
@@ -11,7 +11,7 @@ import { MUser, MUserId, MVideoFullLight } from '@server/types/models'
 import {
  HLSTranscodingPayload,
  MergeAudioTranscodingPayload,
-  NewWebTorrentResolutionTranscodingPayload,
+  NewWebVideoResolutionTranscodingPayload,
  OptimizeTranscodingPayload,
  VideoTranscodingPayload
 } from '@shared/models'
@@ -22,9 +22,9 @@ type HandlerFunction = (job: Job, payload: VideoTranscodingPayload, video: MVide
 const handlers: { [ id in VideoTranscodingPayload['type'] ]: HandlerFunction } = {
  'new-resolution-to-hls': handleHLSJob,
-  'new-resolution-to-webtorrent': handleNewWebTorrentResolutionJob,
+  'new-resolution-to-web-video': handleNewWebVideoResolutionJob,
-  'merge-audio-to-webtorrent': handleWebTorrentMergeAudioJob,
+  'merge-audio-to-web-video': handleWebVideoMergeAudioJob,
-  'optimize-to-webtorrent': handleWebTorrentOptimizeJob
+  'optimize-to-web-video': handleWebVideoOptimizeJob
 }
 const lTags = loggerTagsFactory('transcoding')
@@ -74,7 +74,7 @@ export {
 // Job handlers
 // ---------------------------------------------------------------------------
-async function handleWebTorrentMergeAudioJob (job: Job, payload: MergeAudioTranscodingPayload, video: MVideoFullLight, user: MUserId) {
+async function handleWebVideoMergeAudioJob (job: Job, payload: MergeAudioTranscodingPayload, video: MVideoFullLight, user: MUserId) {
  logger.info('Handling merge audio transcoding job for %s.', video.uuid, lTags(video.uuid), { payload })
  await mergeAudioVideofile({ video, resolution: payload.resolution, fps: payload.fps, job })
@@ -84,7 +84,7 @@ async function handleWebTorrentMergeAudioJob (job: Job, payload: MergeAudioTrans
  await onTranscodingEnded({ isNewVideo: payload.isNewVideo, moveVideoToNextState: !payload.hasChildren, video })
 }
-async function handleWebTorrentOptimizeJob (job: Job, payload: OptimizeTranscodingPayload, video: MVideoFullLight, user: MUserId) {
+async function handleWebVideoOptimizeJob (job: Job, payload: OptimizeTranscodingPayload, video: MVideoFullLight, user: MUserId) {
  logger.info('Handling optimize transcoding job for %s.', video.uuid, lTags(video.uuid), { payload })
  await optimizeOriginalVideofile({ video, inputVideoFile: video.getMaxQualityFile(), quickTranscode: payload.quickTranscode, job })
@@ -96,12 +96,12 @@ async function handleWebTorrentOptimizeJob (job: Job, payload: OptimizeTranscodi
 // ---------------------------------------------------------------------------
-async function handleNewWebTorrentResolutionJob (job: Job, payload: NewWebTorrentResolutionTranscodingPayload, video: MVideoFullLight) {
+async function handleNewWebVideoResolutionJob (job: Job, payload: NewWebVideoResolutionTranscodingPayload, video: MVideoFullLight) {
-  logger.info('Handling WebTorrent transcoding job for %s.', video.uuid, lTags(video.uuid), { payload })
+  logger.info('Handling Web Video transcoding job for %s.', video.uuid, lTags(video.uuid), { payload })
-  await transcodeNewWebTorrentResolution({ video, resolution: payload.resolution, fps: payload.fps, job })
+  await transcodeNewWebVideoResolution({ video, resolution: payload.resolution, fps: payload.fps, job })
-  logger.info('WebTorrent transcoding job for %s ended.', video.uuid, lTags(video.uuid), { payload })
+  logger.info('Web Video transcoding job for %s ended.', video.uuid, lTags(video.uuid), { payload })
  await onTranscodingEnded({ isNewVideo: payload.isNewVideo, moveVideoToNextState: true, video })
 }
@@ -118,7 +118,7 @@ async function handleHLSJob (job: Job, payload: HLSTranscodingPayload, videoArg:
    video = await VideoModel.loadFull(videoArg.uuid)
    const videoFileInput = payload.copyCodecs
-      ? video.getWebTorrentFile(payload.resolution)
+      ? video.getWebVideoFile(payload.resolution)
      : video.getMaxQualityFile()
    const videoOrStreamingPlaylist = videoFileInput.getVideoOrStreamingPlaylist()
@@ -140,10 +140,10 @@ async function handleHLSJob (job: Job, payload: HLSTranscodingPayload, videoArg:
  logger.info('HLS transcoding job for %s ended.', video.uuid, lTags(video.uuid), { payload })
-  if (payload.deleteWebTorrentFiles === true) {
+  if (payload.deleteWebVideoFiles === true) {
-    logger.info('Removing WebTorrent files of %s now we have a HLS version of it.', video.uuid, lTags(video.uuid))
+    logger.info('Removing Web Video files of %s now we have a HLS version of it.', video.uuid, lTags(video.uuid))
-    await removeAllWebTorrentFiles(video)
+    await removeAllWebVideoFiles(video)
  }
  await onTranscodingEnded({ isNewVideo: payload.isNewVideo, moveVideoToNextState: true, video })
diff --git a/server/lib/job-queue/job-queue.ts b/server/lib/job-queue/job-queue.ts
index 03f6fbea7..177bca285 100644
--- a/server/lib/job-queue/job-queue.ts
+++ b/server/lib/job-queue/job-queue.ts
@@ -25,6 +25,7 @@ import {
  DeleteResumableUploadMetaFilePayload,
  EmailPayload,
  FederateVideoPayload,
+  GenerateStoryboardPayload,
  JobState,
  JobType,
  ManageVideoTorrentPayload,
@@ -65,6 +66,7 @@ import { processVideoLiveEnding } from './handlers/video-live-ending'
 import { processVideoStudioEdition } from './handlers/video-studio-edition'
 import { processVideoTranscoding } from './handlers/video-transcoding'
 import { processVideosViewsStats } from './handlers/video-views-stats'
+import { processGenerateStoryboard } from './handlers/generate-storyboard'
 export type CreateJobArgument =
  { type: 'activitypub-http-broadcast', payload: ActivitypubHttpBroadcastPayload } |
@@ -91,7 +93,8 @@ export type CreateJobArgument =
  { type: 'after-video-channel-import', payload: AfterVideoChannelImportPayload } |
  { type: 'notify', payload: NotifyPayload } |
  { type: 'move-to-object-storage', payload: MoveObjectStoragePayload } |
-  { type: 'federate-video', payload: FederateVideoPayload }
+  { type: 'federate-video', payload: FederateVideoPayload } |
+  { type: 'generate-video-storyboard', payload: GenerateStoryboardPayload }
 export type CreateJobOptions = {
  delay?: number
@@ -122,7 +125,8 @@ const handlers: { [id in JobType]: (job: Job) => Promise<any> } = {
  'video-redundancy': processVideoRedundancy,
  'video-studio-edition': processVideoStudioEdition,
  'video-transcoding': processVideoTranscoding,
-  'videos-views-stats': processVideosViewsStats
+  'videos-views-stats': processVideosViewsStats,
+  'generate-video-storyboard': processGenerateStoryboard
 }
 const errorHandlers: { [id in JobType]?: (job: Job, err: any) => Promise<any> } = {
@@ -141,10 +145,11 @@ const jobTypes: JobType[] = [
  'after-video-channel-import',
  'email',
  'federate-video',
-  'transcoding-job-builder',
+  'generate-video-storyboard',
  'manage-video-torrent',
  'move-to-object-storage',
  'notify',
+  'transcoding-job-builder',
  'video-channel-import',
  'video-file-import',
  'video-import',
diff --git a/server/lib/local-actor.ts b/server/lib/local-actor.ts
index 16dc265a3..611e6d0af 100644
--- a/server/lib/local-actor.ts
+++ b/server/lib/local-actor.ts
@@ -1,5 +1,4 @@
 import { remove } from 'fs-extra'
-import { LRUCache } from 'lru-cache'
 import { join } from 'path'
 import { Transaction } from 'sequelize/types'
 import { ActorModel } from '@server/models/actor/actor'
@@ -8,14 +7,14 @@ import { buildUUID } from '@shared/extra-utils'
 import { ActivityPubActorType, ActorImageType } from '@shared/models'
 import { retryTransactionWrapper } from '../helpers/database-utils'
 import { CONFIG } from '../initializers/config'
-import { ACTOR_IMAGES_SIZE, LRU_CACHE, WEBSERVER } from '../initializers/constants'
+import { ACTOR_IMAGES_SIZE, WEBSERVER } from '../initializers/constants'
 import { sequelizeTypescript } from '../initializers/database'
 import { MAccountDefault, MActor, MChannelDefault } from '../types/models'
 import { deleteActorImages, updateActorImages } from './activitypub/actors'
 import { sendUpdateActor } from './activitypub/send'
-import { downloadImageFromWorker, processImageFromWorker } from './worker/parent-process'
+import { processImageFromWorker } from './worker/parent-process'
-function buildActorInstance (type: ActivityPubActorType, url: string, preferredUsername: string) {
+export function buildActorInstance (type: ActivityPubActorType, url: string, preferredUsername: string) {
  return new ActorModel({
    type,
    url,
@@ -32,7 +31,7 @@ function buildActorInstance (type: ActivityPubActorType, url: string, preferredU
  }) as MActor
 }
-async function updateLocalActorImageFiles (
+export async function updateLocalActorImageFiles (
  accountOrChannel: MAccountDefault | MChannelDefault,
  imagePhysicalFile: Express.Multer.File,
  type: ActorImageType
@@ -41,7 +40,7 @@ async function updateLocalActorImageFiles (
    const extension = getLowercaseExtension(imagePhysicalFile.filename)
    const imageName = buildUUID() + extension
-    const destination = join(CONFIG.STORAGE.ACTOR_IMAGES, imageName)
+    const destination = join(CONFIG.STORAGE.ACTOR_IMAGES_DIR, imageName)
    await processImageFromWorker({ path: imagePhysicalFile.path, destination, newSize: imageSize, keepOriginal: true })
    return {
@@ -73,7 +72,7 @@ async function updateLocalActorImageFiles (
  }))
 }
-async function deleteLocalActorImageFile (accountOrChannel: MAccountDefault | MChannelDefault, type: ActorImageType) {
+export async function deleteLocalActorImageFile (accountOrChannel: MAccountDefault | MChannelDefault, type: ActorImageType) {
  return retryTransactionWrapper(() => {
    return sequelizeTypescript.transaction(async t => {
      const updatedActor = await deleteActorImages(accountOrChannel.Actor, type, t)
@@ -88,7 +87,7 @@ async function deleteLocalActorImageFile (accountOrChannel: MAccountDefault | MC
 // ---------------------------------------------------------------------------
-async function findAvailableLocalActorName (baseActorName: string, transaction?: Transaction) {
+export async function findAvailableLocalActorName (baseActorName: string, transaction?: Transaction) {
  let actor = await ActorModel.loadLocalByName(baseActorName, transaction)
  if (!actor) return baseActorName
@@ -101,34 +100,3 @@ async function findAvailableLocalActorName (baseActorName: string, transaction?:
  throw new Error('Cannot find available actor local name (too much iterations).')
 }
-// ---------------------------------------------------------------------------
-function downloadActorImageFromWorker (options: {
-  fileUrl: string
-  filename: string
-  type: ActorImageType
-  size: typeof ACTOR_IMAGES_SIZE[ActorImageType][0]
-}) {
-  const downloaderOptions = {
-    url: options.fileUrl,
-    destDir: CONFIG.STORAGE.ACTOR_IMAGES,
-    destName: options.filename,
-    size: options.size
-  }
-  return downloadImageFromWorker(downloaderOptions)
-}
-// Unsafe so could returns paths that does not exist anymore
-const actorImagePathUnsafeCache = new LRUCache<string, string>({ max: LRU_CACHE.ACTOR_IMAGE_STATIC.MAX_SIZE })
-export {
-  actorImagePathUnsafeCache,
-  updateLocalActorImageFiles,
-  findAvailableLocalActorName,
-  downloadActorImageFromWorker,
-  deleteLocalActorImageFile,
-  downloadImageFromWorker,
-  buildActorInstance
-}
diff --git a/server/lib/object-storage/index.ts b/server/lib/object-storage/index.ts
index 6525f8dfb..3ad6cab63 100644
--- a/server/lib/object-storage/index.ts
+++ b/server/lib/object-storage/index.ts
@@ -1,4 +1,5 @@
 export * from './keys'
 export * from './proxy'
+export * from './pre-signed-urls'
 export * from './urls'
 export * from './videos'
diff --git a/server/lib/object-storage/keys.ts b/server/lib/object-storage/keys.ts
index 4f17073f4..6d2098298 100644
--- a/server/lib/object-storage/keys.ts
+++ b/server/lib/object-storage/keys.ts
@@ -9,12 +9,12 @@ function generateHLSObjectBaseStorageKey (playlist: MStreamingPlaylistVideo) {
  return join(playlist.getStringType(), playlist.Video.uuid)
 }
-function generateWebTorrentObjectStorageKey (filename: string) {
+function generateWebVideoObjectStorageKey (filename: string) {
  return filename
 }
 export {
  generateHLSObjectStorageKey,
  generateHLSObjectBaseStorageKey,
-  generateWebTorrentObjectStorageKey
+  generateWebVideoObjectStorageKey
 }
diff --git a/server/lib/object-storage/pre-signed-urls.ts b/server/lib/object-storage/pre-signed-urls.ts
new file mode 100644
index 000000000..caf149bb8
--- /dev/null
+++ b/server/lib/object-storage/pre-signed-urls.ts
@@ -0,0 +1,46 @@
+import { GetObjectCommand } from '@aws-sdk/client-s3'
+import { getSignedUrl } from '@aws-sdk/s3-request-presigner'
+import { CONFIG } from '@server/initializers/config'
+import { MStreamingPlaylistVideo, MVideoFile } from '@server/types/models'
+import { generateHLSObjectStorageKey, generateWebVideoObjectStorageKey } from './keys'
+import { buildKey, getClient } from './shared'
+import { getHLSPublicFileUrl, getWebVideoPublicFileUrl } from './urls'
+export async function generateWebVideoPresignedUrl (options: {
+  file: MVideoFile
+  downloadFilename: string
+}) {
+  const { file, downloadFilename } = options
+  const key = generateWebVideoObjectStorageKey(file.filename)
+  const command = new GetObjectCommand({
+    Bucket: CONFIG.OBJECT_STORAGE.WEB_VIDEOS.BUCKET_NAME,
+    Key: buildKey(key, CONFIG.OBJECT_STORAGE.WEB_VIDEOS),
+    ResponseContentDisposition: `attachment; filename=${downloadFilename}`
+  })
+  const url = await getSignedUrl(getClient(), command, { expiresIn: 3600 * 24 })
+  return getWebVideoPublicFileUrl(url)
+}
+export async function generateHLSFilePresignedUrl (options: {
+  streamingPlaylist: MStreamingPlaylistVideo
+  file: MVideoFile
+  downloadFilename: string
+}) {
+  const { streamingPlaylist, file, downloadFilename } = options
+  const key = generateHLSObjectStorageKey(streamingPlaylist, file.filename)
+  const command = new GetObjectCommand({
+    Bucket: CONFIG.OBJECT_STORAGE.STREAMING_PLAYLISTS.BUCKET_NAME,
+    Key: buildKey(key, CONFIG.OBJECT_STORAGE.STREAMING_PLAYLISTS),
+    ResponseContentDisposition: `attachment; filename=${downloadFilename}`
+  })
+  const url = await getSignedUrl(getClient(), command, { expiresIn: 3600 * 24 })
+  return getHLSPublicFileUrl(url)
+}
diff --git a/server/lib/object-storage/proxy.ts b/server/lib/object-storage/proxy.ts
index c782a8a25..c09a0d1b0 100644
--- a/server/lib/object-storage/proxy.ts
+++ b/server/lib/object-storage/proxy.ts
@@ -7,19 +7,19 @@ import { StreamReplacer } from '@server/helpers/stream-replacer'
 import { MStreamingPlaylist, MVideo } from '@server/types/models'
 import { HttpStatusCode } from '@shared/models'
 import { injectQueryToPlaylistUrls } from '../hls'
-import { getHLSFileReadStream, getWebTorrentFileReadStream } from './videos'
+import { getHLSFileReadStream, getWebVideoFileReadStream } from './videos'
-export async function proxifyWebTorrentFile (options: {
+export async function proxifyWebVideoFile (options: {
  req: express.Request
  res: express.Response
  filename: string
 }) {
  const { req, res, filename } = options
-  logger.debug('Proxifying WebTorrent file %s from object storage.', filename)
+  logger.debug('Proxifying Web Video file %s from object storage.', filename)
  try {
-    const { response: s3Response, stream } = await getWebTorrentFileReadStream({
+    const { response: s3Response, stream } = await getWebVideoFileReadStream({
      filename,
      rangeHeader: req.header('range')
    })
diff --git a/server/lib/object-storage/urls.ts b/server/lib/object-storage/urls.ts
index b8ef94559..40619cd5a 100644
--- a/server/lib/object-storage/urls.ts
+++ b/server/lib/object-storage/urls.ts
@@ -9,8 +9,8 @@ function getInternalUrl (config: BucketInfo, keyWithoutPrefix: string) {
 // ---------------------------------------------------------------------------
-function getWebTorrentPublicFileUrl (fileUrl: string) {
+function getWebVideoPublicFileUrl (fileUrl: string) {
-  const baseUrl = CONFIG.OBJECT_STORAGE.VIDEOS.BASE_URL
+  const baseUrl = CONFIG.OBJECT_STORAGE.WEB_VIDEOS.BASE_URL
  if (!baseUrl) return fileUrl
  return replaceByBaseUrl(fileUrl, baseUrl)
@@ -29,8 +29,8 @@ function getHLSPrivateFileUrl (video: MVideoUUID, filename: string) {
  return WEBSERVER.URL + OBJECT_STORAGE_PROXY_PATHS.STREAMING_PLAYLISTS.PRIVATE_HLS + video.uuid + `/${filename}`
 }
-function getWebTorrentPrivateFileUrl (filename: string) {
+function getWebVideoPrivateFileUrl (filename: string) {
-  return WEBSERVER.URL + OBJECT_STORAGE_PROXY_PATHS.PRIVATE_WEBSEED + filename
+  return WEBSERVER.URL + OBJECT_STORAGE_PROXY_PATHS.PRIVATE_WEB_VIDEOS + filename
 }
 // ---------------------------------------------------------------------------
@@ -38,11 +38,11 @@ function getWebTorrentPrivateFileUrl (filename: string) {
 export {
  getInternalUrl,
-  getWebTorrentPublicFileUrl,
+  getWebVideoPublicFileUrl,
  getHLSPublicFileUrl,
  getHLSPrivateFileUrl,
-  getWebTorrentPrivateFileUrl,
+  getWebVideoPrivateFileUrl,
  replaceByBaseUrl
 }
diff --git a/server/lib/object-storage/videos.ts b/server/lib/object-storage/videos.ts
index 9152c5352..891e9ff76 100644
--- a/server/lib/object-storage/videos.ts
+++ b/server/lib/object-storage/videos.ts
@@ -4,7 +4,7 @@ import { CONFIG } from '@server/initializers/config'
 import { MStreamingPlaylistVideo, MVideo, MVideoFile } from '@server/types/models'
 import { getHLSDirectory } from '../paths'
 import { VideoPathManager } from '../video-path-manager'
-import { generateHLSObjectBaseStorageKey, generateHLSObjectStorageKey, generateWebTorrentObjectStorageKey } from './keys'
+import { generateHLSObjectBaseStorageKey, generateHLSObjectStorageKey, generateWebVideoObjectStorageKey } from './keys'
 import {
  createObjectReadStream,
  listKeysOfPrefix,
@@ -55,21 +55,21 @@ function storeHLSFileFromContent (playlist: MStreamingPlaylistVideo, path: strin
 // ---------------------------------------------------------------------------
-function storeWebTorrentFile (video: MVideo, file: MVideoFile) {
+function storeWebVideoFile (video: MVideo, file: MVideoFile) {
  return storeObject({
    inputPath: VideoPathManager.Instance.getFSVideoFileOutputPath(video, file),
-    objectStorageKey: generateWebTorrentObjectStorageKey(file.filename),
+    objectStorageKey: generateWebVideoObjectStorageKey(file.filename),
-    bucketInfo: CONFIG.OBJECT_STORAGE.VIDEOS,
+    bucketInfo: CONFIG.OBJECT_STORAGE.WEB_VIDEOS,
    isPrivate: video.hasPrivateStaticPath()
  })
 }
 // ---------------------------------------------------------------------------
-async function updateWebTorrentFileACL (video: MVideo, file: MVideoFile) {
+async function updateWebVideoFileACL (video: MVideo, file: MVideoFile) {
  await updateObjectACL({
-    objectStorageKey: generateWebTorrentObjectStorageKey(file.filename),
+    objectStorageKey: generateWebVideoObjectStorageKey(file.filename),
-    bucketInfo: CONFIG.OBJECT_STORAGE.VIDEOS,
+    bucketInfo: CONFIG.OBJECT_STORAGE.WEB_VIDEOS,
    isPrivate: video.hasPrivateStaticPath()
  })
 }
@@ -102,8 +102,8 @@ function removeHLSFileObjectStorageByFullKey (key: string) {
 // ---------------------------------------------------------------------------
-function removeWebTorrentObjectStorage (videoFile: MVideoFile) {
+function removeWebVideoObjectStorage (videoFile: MVideoFile) {
-  return removeObject(generateWebTorrentObjectStorageKey(videoFile.filename), CONFIG.OBJECT_STORAGE.VIDEOS)
+  return removeObject(generateWebVideoObjectStorageKey(videoFile.filename), CONFIG.OBJECT_STORAGE.WEB_VIDEOS)
 }
 // ---------------------------------------------------------------------------
@@ -122,15 +122,15 @@ async function makeHLSFileAvailable (playlist: MStreamingPlaylistVideo, filename
  return destination
 }
-async function makeWebTorrentFileAvailable (filename: string, destination: string) {
+async function makeWebVideoFileAvailable (filename: string, destination: string) {
-  const key = generateWebTorrentObjectStorageKey(filename)
+  const key = generateWebVideoObjectStorageKey(filename)
-  logger.info('Fetching WebTorrent file %s from object storage to %s.', key, destination, lTags())
+  logger.info('Fetching Web Video file %s from object storage to %s.', key, destination, lTags())
  await makeAvailable({
    key,
    destination,
-    bucketInfo: CONFIG.OBJECT_STORAGE.VIDEOS
+    bucketInfo: CONFIG.OBJECT_STORAGE.WEB_VIDEOS
  })
  return destination
@@ -138,17 +138,17 @@ async function makeWebTorrentFileAvailable (filename: string, destination: strin
 // ---------------------------------------------------------------------------
-function getWebTorrentFileReadStream (options: {
+function getWebVideoFileReadStream (options: {
  filename: string
  rangeHeader: string
 }) {
  const { filename, rangeHeader } = options
-  const key = generateWebTorrentObjectStorageKey(filename)
+  const key = generateWebVideoObjectStorageKey(filename)
  return createObjectReadStream({
    key,
-    bucketInfo: CONFIG.OBJECT_STORAGE.VIDEOS,
+    bucketInfo: CONFIG.OBJECT_STORAGE.WEB_VIDEOS,
    rangeHeader
  })
 }
@@ -174,12 +174,12 @@ function getHLSFileReadStream (options: {
 export {
  listHLSFileKeysOf,
-  storeWebTorrentFile,
+  storeWebVideoFile,
  storeHLSFileFromFilename,
  storeHLSFileFromPath,
  storeHLSFileFromContent,
-  updateWebTorrentFileACL,
+  updateWebVideoFileACL,
  updateHLSFilesACL,
  removeHLSObjectStorage,
@@ -187,11 +187,11 @@ export {
  removeHLSFileObjectStorageByPath,
  removeHLSFileObjectStorageByFullKey,
-  removeWebTorrentObjectStorage,
+  removeWebVideoObjectStorage,
-  makeWebTorrentFileAvailable,
+  makeWebVideoFileAvailable,
  makeHLSFileAvailable,
-  getWebTorrentFileReadStream,
+  getWebVideoFileReadStream,
  getHLSFileReadStream
 }
diff --git a/server/lib/paths.ts b/server/lib/paths.ts
index 470970f55..db1cdede2 100644
--- a/server/lib/paths.ts
+++ b/server/lib/paths.ts
@@ -8,7 +8,7 @@ import { isVideoInPrivateDirectory } from './video-privacy'
 // ################## Video file name ##################
-function generateWebTorrentVideoFilename (resolution: number, extname: string) {
+function generateWebVideoFilename (resolution: number, extname: string) {
  return buildUUID() + '-' + resolution + extname
 }
@@ -76,7 +76,7 @@ function getFSTorrentFilePath (videoFile: MVideoFile) {
 export {
  generateHLSVideoFilename,
-  generateWebTorrentVideoFilename,
+  generateWebVideoFilename,
  generateTorrentFileName,
  getFSTorrentFilePath,
diff --git a/server/lib/plugins/plugin-helpers-builder.ts b/server/lib/plugins/plugin-helpers-builder.ts
index d235f52c0..b4e3eece4 100644
--- a/server/lib/plugins/plugin-helpers-builder.ts
+++ b/server/lib/plugins/plugin-helpers-builder.ts
@@ -104,7 +104,7 @@ function buildVideosHelpers () {
      const video = await VideoModel.loadFull(id)
      if (!video) return undefined
-      const webtorrentVideoFiles = (video.VideoFiles || []).map(f => ({
+      const webVideoFiles = (video.VideoFiles || []).map(f => ({
        path: f.storage === VideoStorage.FILE_SYSTEM
          ? VideoPathManager.Instance.getFSVideoFileOutputPath(video, f)
          : null,
@@ -138,8 +138,12 @@ function buildVideosHelpers () {
      }))
      return {
-        webtorrent: {
+        webtorrent: { // TODO: remove in v7
-          videoFiles: webtorrentVideoFiles
+          videoFiles: webVideoFiles
+        },
+        webVideo: {
+          videoFiles: webVideoFiles
        },
        hls: {
diff --git a/server/lib/redis.ts b/server/lib/redis.ts
index 8430b2227..48d9986b5 100644
--- a/server/lib/redis.ts
+++ b/server/lib/redis.ts
@@ -325,8 +325,8 @@ class Redis {
    const value = await this.getValue('resumable-upload-' + uploadId)
    return value
-      ? JSON.parse(value)
+      ? JSON.parse(value) as { video: { id: number, shortUUID: string, uuid: string } }
-      : ''
+      : undefined
  }
  deleteUploadSession (uploadId: string) {
diff --git a/server/lib/runners/job-handlers/shared/vod-helpers.ts b/server/lib/runners/job-handlers/shared/vod-helpers.ts
index 93ae89ff8..1a2ad02ca 100644
--- a/server/lib/runners/job-handlers/shared/vod-helpers.ts
+++ b/server/lib/runners/job-handlers/shared/vod-helpers.ts
@@ -2,7 +2,7 @@ import { move } from 'fs-extra'
 import { dirname, join } from 'path'
 import { logger, LoggerTagsFn } from '@server/helpers/logger'
 import { onTranscodingEnded } from '@server/lib/transcoding/ended-transcoding'
-import { onWebTorrentVideoFileTranscoding } from '@server/lib/transcoding/web-transcoding'
+import { onWebVideoFileTranscoding } from '@server/lib/transcoding/web-transcoding'
 import { buildNewFile } from '@server/lib/video-file'
 import { VideoModel } from '@server/models/video/video'
 import { MVideoFullLight } from '@server/types/models'
@@ -22,7 +22,7 @@ export async function onVODWebVideoOrAudioMergeTranscodingJob (options: {
  const newVideoFilePath = join(dirname(videoFilePath), videoFile.filename)
  await move(videoFilePath, newVideoFilePath)
-  await onWebTorrentVideoFileTranscoding({
+  await onWebVideoFileTranscoding({
    video,
    videoFile,
    videoOutputPath: newVideoFilePath
diff --git a/server/lib/runners/job-handlers/vod-audio-merge-transcoding-job-handler.ts b/server/lib/runners/job-handlers/vod-audio-merge-transcoding-job-handler.ts
index 5f247d792..905007db9 100644
--- a/server/lib/runners/job-handlers/vod-audio-merge-transcoding-job-handler.ts
+++ b/server/lib/runners/job-handlers/vod-audio-merge-transcoding-job-handler.ts
@@ -83,7 +83,7 @@ export class VODAudioMergeTranscodingJobHandler extends AbstractVODTranscodingJo
    // We can remove the old audio file
    const oldAudioFile = video.VideoFiles[0]
-    await video.removeWebTorrentFile(oldAudioFile)
+    await video.removeWebVideoFile(oldAudioFile)
    await oldAudioFile.destroy()
    video.VideoFiles = []
diff --git a/server/lib/runners/job-handlers/vod-hls-transcoding-job-handler.ts b/server/lib/runners/job-handlers/vod-hls-transcoding-job-handler.ts
index cc94bcbda..02845952c 100644
--- a/server/lib/runners/job-handlers/vod-hls-transcoding-job-handler.ts
+++ b/server/lib/runners/job-handlers/vod-hls-transcoding-job-handler.ts
@@ -5,7 +5,7 @@ import { renameVideoFileInPlaylist } from '@server/lib/hls'
 import { getHlsResolutionPlaylistFilename } from '@server/lib/paths'
 import { onTranscodingEnded } from '@server/lib/transcoding/ended-transcoding'
 import { onHLSVideoFileTranscoding } from '@server/lib/transcoding/hls-transcoding'
-import { buildNewFile, removeAllWebTorrentFiles } from '@server/lib/video-file'
+import { buildNewFile, removeAllWebVideoFiles } from '@server/lib/video-file'
 import { VideoJobInfoModel } from '@server/models/video/video-job-info'
 import { MVideo } from '@server/types/models'
 import { MRunnerJob } from '@server/types/models/runners'
@@ -106,7 +106,7 @@ export class VODHLSTranscodingJobHandler extends AbstractVODTranscodingJobHandle
    if (privatePayload.deleteWebVideoFiles === true) {
      logger.info('Removing web video files of %s now we have a HLS version of it.', video.uuid, this.lTags(video.uuid))
-      await removeAllWebTorrentFiles(video)
+      await removeAllWebVideoFiles(video)
    }
    logger.info('Runner VOD HLS job %s for %s ended.', runnerJob.uuid, video.uuid, this.lTags(runnerJob.uuid, video.uuid))
diff --git a/server/lib/schedulers/videos-redundancy-scheduler.ts b/server/lib/schedulers/videos-redundancy-scheduler.ts
index dc450c338..24d340a73 100644
--- a/server/lib/schedulers/videos-redundancy-scheduler.ts
+++ b/server/lib/schedulers/videos-redundancy-scheduler.ts
@@ -23,7 +23,7 @@ import { getLocalVideoCacheFileActivityPubUrl, getLocalVideoCacheStreamingPlayli
 import { getOrCreateAPVideo } from '../activitypub/videos'
 import { downloadPlaylistSegments } from '../hls'
 import { removeVideoRedundancy } from '../redundancy'
-import { generateHLSRedundancyUrl, generateWebTorrentRedundancyUrl } from '../video-urls'
+import { generateHLSRedundancyUrl, generateWebVideoRedundancyUrl } from '../video-urls'
 import { AbstractScheduler } from './abstract-scheduler'
 const lTags = loggerTagsFactory('redundancy')
@@ -244,7 +244,7 @@ export class VideosRedundancyScheduler extends AbstractScheduler {
    const createdModel: MVideoRedundancyFileVideo = await VideoRedundancyModel.create({
      expiresOn,
      url: getLocalVideoCacheFileActivityPubUrl(file),
-      fileUrl: generateWebTorrentRedundancyUrl(file),
+      fileUrl: generateWebVideoRedundancyUrl(file),
      strategy,
      videoFileId: file.id,
      actorId: serverActor.id
diff --git a/server/lib/server-config-manager.ts b/server/lib/server-config-manager.ts
index 924adb337..5ce89b16d 100644
--- a/server/lib/server-config-manager.ts
+++ b/server/lib/server-config-manager.ts
@@ -132,8 +132,8 @@ class ServerConfigManager {
        hls: {
          enabled: CONFIG.TRANSCODING.ENABLED && CONFIG.TRANSCODING.HLS.ENABLED
        },
-        webtorrent: {
+        web_videos: {
-          enabled: CONFIG.TRANSCODING.ENABLED && CONFIG.TRANSCODING.WEBTORRENT.ENABLED
+          enabled: CONFIG.TRANSCODING.ENABLED && CONFIG.TRANSCODING.WEB_VIDEOS.ENABLED
        },
        enabledResolutions: this.getEnabledResolutions('vod'),
        profile: CONFIG.TRANSCODING.PROFILE,
diff --git a/server/lib/thumbnail.ts b/server/lib/thumbnail.ts
index 02b867a91..d95442795 100644
--- a/server/lib/thumbnail.ts
+++ b/server/lib/thumbnail.ts
@@ -7,13 +7,12 @@ import { ThumbnailModel } from '../models/video/thumbnail'
 import { MVideoFile, MVideoThumbnail, MVideoUUID } from '../types/models'
 import { MThumbnail } from '../types/models/video/thumbnail'
 import { MVideoPlaylistThumbnail } from '../types/models/video/video-playlist'
-import { downloadImageFromWorker } from './local-actor'
 import { VideoPathManager } from './video-path-manager'
-import { processImageFromWorker } from './worker/parent-process'
+import { downloadImageFromWorker, processImageFromWorker } from './worker/parent-process'
 type ImageSize = { height?: number, width?: number }
-function updatePlaylistMiniatureFromExisting (options: {
+function updateLocalPlaylistMiniatureFromExisting (options: {
  inputPath: string
  playlist: MVideoPlaylistThumbnail
  automaticallyGenerated: boolean
@@ -35,11 +34,12 @@ function updatePlaylistMiniatureFromExisting (options: {
    width,
    type,
    automaticallyGenerated,
+    onDisk: true,
    existingThumbnail
  })
 }
-function updatePlaylistMiniatureFromUrl (options: {
+function updateRemotePlaylistMiniatureFromUrl (options: {
  downloadUrl: string
  playlist: MVideoPlaylistThumbnail
  size?: ImageSize
@@ -57,42 +57,10 @@ function updatePlaylistMiniatureFromUrl (options: {
    return downloadImageFromWorker({ url: downloadUrl, destDir: basePath, destName: filename, size: { width, height } })
  }
-  return updateThumbnailFromFunction({ thumbnailCreator, filename, height, width, type, existingThumbnail, fileUrl })
+  return updateThumbnailFromFunction({ thumbnailCreator, filename, height, width, type, existingThumbnail, fileUrl, onDisk: true })
 }
-function updateVideoMiniatureFromUrl (options: {
+function updateLocalVideoMiniatureFromExisting (options: {
-  downloadUrl: string
-  video: MVideoThumbnail
-  type: ThumbnailType
-  size?: ImageSize
-}) {
-  const { downloadUrl, video, type, size } = options
-  const { filename: updatedFilename, basePath, height, width, existingThumbnail } = buildMetadataFromVideo(video, type, size)
-  // Only save the file URL if it is a remote video
-  const fileUrl = video.isOwned()
-    ? null
-    : downloadUrl
-  const thumbnailUrlChanged = hasThumbnailUrlChanged(existingThumbnail, downloadUrl, video)
-  // Do not change the thumbnail filename if the file did not change
-  const filename = thumbnailUrlChanged
-    ? updatedFilename
-    : existingThumbnail.filename
-  const thumbnailCreator = () => {
-    if (thumbnailUrlChanged) {
-      return downloadImageFromWorker({ url: downloadUrl, destDir: basePath, destName: filename, size: { width, height } })
-    }
-    return Promise.resolve()
-  }
-  return updateThumbnailFromFunction({ thumbnailCreator, filename, height, width, type, existingThumbnail, fileUrl })
-}
-function updateVideoMiniatureFromExisting (options: {
  inputPath: string
  video: MVideoThumbnail
  type: ThumbnailType
@@ -115,11 +83,12 @@ function updateVideoMiniatureFromExisting (options: {
    width,
    type,
    automaticallyGenerated,
-    existingThumbnail
+    existingThumbnail,
+    onDisk: true
  })
 }
-function generateVideoMiniature (options: {
+function generateLocalVideoMiniature (options: {
  video: MVideoThumbnail
  videoFile: MVideoFile
  type: ThumbnailType
@@ -150,34 +119,68 @@ function generateVideoMiniature (options: {
      width,
      type,
      automaticallyGenerated: true,
+      onDisk: true,
      existingThumbnail
    })
  })
 }
-function updatePlaceholderThumbnail (options: {
+// ---------------------------------------------------------------------------
-  fileUrl: string
+function updateLocalVideoMiniatureFromUrl (options: {
+  downloadUrl: string
  video: MVideoThumbnail
  type: ThumbnailType
-  size: ImageSize
+  size?: ImageSize
 }) {
-  const { fileUrl, video, type, size } = options
+  const { downloadUrl, video, type, size } = options
-  const { filename: updatedFilename, height, width, existingThumbnail } = buildMetadataFromVideo(video, type, size)
+  const { filename: updatedFilename, basePath, height, width, existingThumbnail } = buildMetadataFromVideo(video, type, size)
-  const thumbnailUrlChanged = hasThumbnailUrlChanged(existingThumbnail, fileUrl, video)
+  // Only save the file URL if it is a remote video
+  const fileUrl = video.isOwned()
+    ? null
+    : downloadUrl
-  const thumbnail = existingThumbnail || new ThumbnailModel()
+  const thumbnailUrlChanged = hasThumbnailUrlChanged(existingThumbnail, downloadUrl, video)
  // Do not change the thumbnail filename if the file did not change
  const filename = thumbnailUrlChanged
    ? updatedFilename
    : existingThumbnail.filename
-  thumbnail.filename = filename
+  const thumbnailCreator = () => {
+    if (thumbnailUrlChanged) {
+      return downloadImageFromWorker({ url: downloadUrl, destDir: basePath, destName: filename, size: { width, height } })
+    }
+    return Promise.resolve()
+  }
+  return updateThumbnailFromFunction({ thumbnailCreator, filename, height, width, type, existingThumbnail, fileUrl, onDisk: true })
+}
+function updateRemoteVideoThumbnail (options: {
+  fileUrl: string
+  video: MVideoThumbnail
+  type: ThumbnailType
+  size: ImageSize
+  onDisk: boolean
+}) {
+  const { fileUrl, video, type, size, onDisk } = options
+  const { filename: generatedFilename, height, width, existingThumbnail } = buildMetadataFromVideo(video, type, size)
+  const thumbnail = existingThumbnail || new ThumbnailModel()
+  // Do not change the thumbnail filename if the file did not change
+  if (hasThumbnailUrlChanged(existingThumbnail, fileUrl, video)) {
+    thumbnail.filename = generatedFilename
+  }
  thumbnail.height = height
  thumbnail.width = width
  thumbnail.type = type
  thumbnail.fileUrl = fileUrl
+  thumbnail.onDisk = onDisk
  return thumbnail
 }
@@ -185,14 +188,18 @@ function updatePlaceholderThumbnail (options: {
 // ---------------------------------------------------------------------------
 export {
-  generateVideoMiniature,
+  generateLocalVideoMiniature,
-  updateVideoMiniatureFromUrl,
+  updateLocalVideoMiniatureFromUrl,
-  updateVideoMiniatureFromExisting,
+  updateLocalVideoMiniatureFromExisting,
-  updatePlaceholderThumbnail,
+  updateRemoteVideoThumbnail,
-  updatePlaylistMiniatureFromUrl,
+  updateRemotePlaylistMiniatureFromUrl,
-  updatePlaylistMiniatureFromExisting
+  updateLocalPlaylistMiniatureFromExisting
 }
+// ---------------------------------------------------------------------------
+// Private
+// ---------------------------------------------------------------------------
 function hasThumbnailUrlChanged (existingThumbnail: MThumbnail, downloadUrl: string, video: MVideoUUID) {
  const existingUrl = existingThumbnail
    ? existingThumbnail.fileUrl
@@ -258,6 +265,7 @@ async function updateThumbnailFromFunction (parameters: {
  height: number
  width: number
  type: ThumbnailType
+  onDisk: boolean
  automaticallyGenerated?: boolean
  fileUrl?: string
  existingThumbnail?: MThumbnail
@@ -269,6 +277,7 @@ async function updateThumbnailFromFunction (parameters: {
    height,
    type,
    existingThumbnail,
+    onDisk,
    automaticallyGenerated = null,
    fileUrl = null
  } = parameters
@@ -285,6 +294,7 @@ async function updateThumbnailFromFunction (parameters: {
  thumbnail.type = type
  thumbnail.fileUrl = fileUrl
  thumbnail.automaticallyGenerated = automaticallyGenerated
+  thumbnail.onDisk = onDisk
  if (oldFilename) thumbnail.previousThumbnailFilename = oldFilename
diff --git a/server/lib/transcoding/create-transcoding-job.ts b/server/lib/transcoding/create-transcoding-job.ts
index abe32684d..d78e68b87 100644
--- a/server/lib/transcoding/create-transcoding-job.ts
+++ b/server/lib/transcoding/create-transcoding-job.ts
@@ -15,7 +15,7 @@ export function createOptimizeOrMergeAudioJobs (options: {
 // ---------------------------------------------------------------------------
 export function createTranscodingJobs (options: {
-  transcodingType: 'hls' | 'webtorrent'
+  transcodingType: 'hls' | 'webtorrent' | 'web-video' // TODO: remove webtorrent in v7
  video: MVideoFullLight
  resolutions: number[]
  isNewVideo: boolean
diff --git a/server/lib/transcoding/shared/job-builders/abstract-job-builder.ts b/server/lib/transcoding/shared/job-builders/abstract-job-builder.ts
index 80dc05bfb..15fc814ae 100644
--- a/server/lib/transcoding/shared/job-builders/abstract-job-builder.ts
+++ b/server/lib/transcoding/shared/job-builders/abstract-job-builder.ts
@@ -12,7 +12,7 @@ export abstract class AbstractJobBuilder {
  }): Promise<any>
  abstract createTranscodingJobs (options: {
-    transcodingType: 'hls' | 'webtorrent'
+    transcodingType: 'hls' | 'webtorrent' | 'web-video' // TODO: remove webtorrent in v7
    video: MVideoFullLight
    resolutions: number[]
    isNewVideo: boolean
diff --git a/server/lib/transcoding/shared/job-builders/transcoding-job-queue-builder.ts b/server/lib/transcoding/shared/job-builders/transcoding-job-queue-builder.ts
index 4f802e2a6..0505c2b2f 100644
--- a/server/lib/transcoding/shared/job-builders/transcoding-job-queue-builder.ts
+++ b/server/lib/transcoding/shared/job-builders/transcoding-job-queue-builder.ts
@@ -12,7 +12,7 @@ import { ffprobePromise, getVideoStreamDimensionsInfo, getVideoStreamFPS, hasAud
 import {
  HLSTranscodingPayload,
  MergeAudioTranscodingPayload,
-  NewWebTorrentResolutionTranscodingPayload,
+  NewWebVideoResolutionTranscodingPayload,
  OptimizeTranscodingPayload,
  VideoTranscodingPayload
 } from '@shared/models'
@@ -33,7 +33,7 @@ export class TranscodingJobQueueBuilder extends AbstractJobBuilder {
    const { video, videoFile, isNewVideo, user, videoFileAlreadyLocked } = options
    let mergeOrOptimizePayload: MergeAudioTranscodingPayload | OptimizeTranscodingPayload
-    let nextTranscodingSequentialJobPayloads: (NewWebTorrentResolutionTranscodingPayload | HLSTranscodingPayload)[][] = []
+    let nextTranscodingSequentialJobPayloads: (NewWebVideoResolutionTranscodingPayload | HLSTranscodingPayload)[][] = []
    const mutexReleaser = videoFileAlreadyLocked
      ? () => {}
@@ -60,7 +60,7 @@ export class TranscodingJobQueueBuilder extends AbstractJobBuilder {
        if (CONFIG.TRANSCODING.HLS.ENABLED === true) {
          nextTranscodingSequentialJobPayloads.push([
            this.buildHLSJobPayload({
-              deleteWebTorrentFiles: CONFIG.TRANSCODING.WEBTORRENT.ENABLED === false,
+              deleteWebVideoFiles: CONFIG.TRANSCODING.WEB_VIDEOS.ENABLED === false,
              // We had some issues with a web video quick transcoded while producing a HLS version of it
              copyCodecs: !quickTranscode,
@@ -116,7 +116,7 @@ export class TranscodingJobQueueBuilder extends AbstractJobBuilder {
  // ---------------------------------------------------------------------------
  async createTranscodingJobs (options: {
-    transcodingType: 'hls' | 'webtorrent'
+    transcodingType: 'hls' | 'webtorrent' | 'web-video' // TODO: remove webtorrent in v7
    video: MVideoFullLight
    resolutions: number[]
    isNewVideo: boolean
@@ -138,8 +138,8 @@ export class TranscodingJobQueueBuilder extends AbstractJobBuilder {
        return this.buildHLSJobPayload({ videoUUID: video.uuid, resolution, fps, isNewVideo })
      }
-      if (transcodingType === 'webtorrent') {
+      if (transcodingType === 'webtorrent' || transcodingType === 'web-video') {
-        return this.buildWebTorrentJobPayload({ videoUUID: video.uuid, resolution, fps, isNewVideo })
+        return this.buildWebVideoJobPayload({ videoUUID: video.uuid, resolution, fps, isNewVideo })
      }
      throw new Error('Unknown transcoding type')
@@ -149,7 +149,7 @@ export class TranscodingJobQueueBuilder extends AbstractJobBuilder {
    const parent = transcodingType === 'hls'
      ? this.buildHLSJobPayload({ videoUUID: video.uuid, resolution: maxResolution, fps, isNewVideo })
-      : this.buildWebTorrentJobPayload({ videoUUID: video.uuid, resolution: maxResolution, fps, isNewVideo })
+      : this.buildWebVideoJobPayload({ videoUUID: video.uuid, resolution: maxResolution, fps, isNewVideo })
    // Process the last resolution after the other ones to prevent concurrency issue
    // Because low resolutions use the biggest one as ffmpeg input
@@ -160,8 +160,8 @@ export class TranscodingJobQueueBuilder extends AbstractJobBuilder {
  private async createTranscodingJobsWithChildren (options: {
    videoUUID: string
-    parent: (HLSTranscodingPayload | NewWebTorrentResolutionTranscodingPayload)
+    parent: (HLSTranscodingPayload | NewWebVideoResolutionTranscodingPayload)
-    children: (HLSTranscodingPayload | NewWebTorrentResolutionTranscodingPayload)[]
+    children: (HLSTranscodingPayload | NewWebVideoResolutionTranscodingPayload)[]
    user: MUserId | null
  }) {
    const { videoUUID, parent, children, user } = options
@@ -203,14 +203,14 @@ export class TranscodingJobQueueBuilder extends AbstractJobBuilder {
      options
    )
-    const sequentialPayloads: (NewWebTorrentResolutionTranscodingPayload | HLSTranscodingPayload)[][] = []
+    const sequentialPayloads: (NewWebVideoResolutionTranscodingPayload | HLSTranscodingPayload)[][] = []
    for (const resolution of resolutionsEnabled) {
      const fps = computeOutputFPS({ inputFPS: inputVideoFPS, resolution })
-      if (CONFIG.TRANSCODING.WEBTORRENT.ENABLED) {
+      if (CONFIG.TRANSCODING.WEB_VIDEOS.ENABLED) {
-        const payloads: (NewWebTorrentResolutionTranscodingPayload | HLSTranscodingPayload)[] = [
+        const payloads: (NewWebVideoResolutionTranscodingPayload | HLSTranscodingPayload)[] = [
-          this.buildWebTorrentJobPayload({
+          this.buildWebVideoJobPayload({
            videoUUID: video.uuid,
            resolution,
            fps,
@@ -253,10 +253,10 @@ export class TranscodingJobQueueBuilder extends AbstractJobBuilder {
    resolution: number
    fps: number
    isNewVideo: boolean
-    deleteWebTorrentFiles?: boolean // default false
+    deleteWebVideoFiles?: boolean // default false
    copyCodecs?: boolean // default false
  }): HLSTranscodingPayload {
-    const { videoUUID, resolution, fps, isNewVideo, deleteWebTorrentFiles = false, copyCodecs = false } = options
+    const { videoUUID, resolution, fps, isNewVideo, deleteWebVideoFiles = false, copyCodecs = false } = options
    return {
      type: 'new-resolution-to-hls',
@@ -265,20 +265,20 @@ export class TranscodingJobQueueBuilder extends AbstractJobBuilder {
      fps,
      copyCodecs,
      isNewVideo,
-      deleteWebTorrentFiles
+      deleteWebVideoFiles
    }
  }
-  private buildWebTorrentJobPayload (options: {
+  private buildWebVideoJobPayload (options: {
    videoUUID: string
    resolution: number
    fps: number
    isNewVideo: boolean
-  }): NewWebTorrentResolutionTranscodingPayload {
+  }): NewWebVideoResolutionTranscodingPayload {
    const { videoUUID, resolution, fps, isNewVideo } = options
    return {
-      type: 'new-resolution-to-webtorrent',
+      type: 'new-resolution-to-web-video',
      videoUUID,
      isNewVideo,
      resolution,
@@ -294,7 +294,7 @@ export class TranscodingJobQueueBuilder extends AbstractJobBuilder {
    const { videoUUID, isNewVideo, hasChildren } = options
    return {
-      type: 'merge-audio-to-webtorrent',
+      type: 'merge-audio-to-web-video',
      resolution: DEFAULT_AUDIO_RESOLUTION,
      fps: VIDEO_TRANSCODING_FPS.AUDIO_MERGE,
      videoUUID,
@@ -312,7 +312,7 @@ export class TranscodingJobQueueBuilder extends AbstractJobBuilder {
    const { videoUUID, quickTranscode, isNewVideo, hasChildren } = options
    return {
-      type: 'optimize-to-webtorrent',
+      type: 'optimize-to-web-video',
      videoUUID,
      isNewVideo,
      hasChildren,
diff --git a/server/lib/transcoding/shared/job-builders/transcoding-runner-job-builder.ts b/server/lib/transcoding/shared/job-builders/transcoding-runner-job-builder.ts
index ba2a46f44..f0671bd7a 100644
--- a/server/lib/transcoding/shared/job-builders/transcoding-runner-job-builder.ts
+++ b/server/lib/transcoding/shared/job-builders/transcoding-runner-job-builder.ts
@@ -62,7 +62,7 @@ export class TranscodingRunnerJobBuilder extends AbstractJobBuilder {
        if (CONFIG.TRANSCODING.HLS.ENABLED === true) {
          await new VODHLSTranscodingJobHandler().create({
            video,
-            deleteWebVideoFiles: CONFIG.TRANSCODING.WEBTORRENT.ENABLED === false,
+            deleteWebVideoFiles: CONFIG.TRANSCODING.WEB_VIDEOS.ENABLED === false,
            resolution: maxResolution,
            fps,
            isNewVideo,
@@ -89,7 +89,7 @@ export class TranscodingRunnerJobBuilder extends AbstractJobBuilder {
  // ---------------------------------------------------------------------------
  async createTranscodingJobs (options: {
-    transcodingType: 'hls' | 'webtorrent'
+    transcodingType: 'hls' | 'webtorrent' | 'web-video' // TODO: remove webtorrent in v7
    video: MVideoFullLight
    resolutions: number[]
    isNewVideo: boolean
@@ -130,7 +130,7 @@ export class TranscodingRunnerJobBuilder extends AbstractJobBuilder {
        continue
      }
-      if (transcodingType === 'webtorrent') {
+      if (transcodingType === 'webtorrent' || transcodingType === 'web-video') {
        await new VODWebVideoTranscodingJobHandler().create({
          video,
          resolution,
@@ -169,7 +169,7 @@ export class TranscodingRunnerJobBuilder extends AbstractJobBuilder {
    for (const resolution of resolutionsEnabled) {
      const fps = computeOutputFPS({ inputFPS: inputVideoFPS, resolution })
-      if (CONFIG.TRANSCODING.WEBTORRENT.ENABLED) {
+      if (CONFIG.TRANSCODING.WEB_VIDEOS.ENABLED) {
        await new VODWebVideoTranscodingJobHandler().create({
          video,
          resolution,
diff --git a/server/lib/transcoding/web-transcoding.ts b/server/lib/transcoding/web-transcoding.ts
index 7cc8f20bc..f92d457a0 100644
--- a/server/lib/transcoding/web-transcoding.ts
+++ b/server/lib/transcoding/web-transcoding.ts
@@ -9,7 +9,8 @@ import { ffprobePromise, getVideoStreamDuration, getVideoStreamFPS, TranscodeVOD
 import { VideoResolution, VideoStorage } from '@shared/models'
 import { CONFIG } from '../../initializers/config'
 import { VideoFileModel } from '../../models/video/video-file'
-import { generateWebTorrentVideoFilename } from '../paths'
+import { JobQueue } from '../job-queue'
+import { generateWebVideoFilename } from '../paths'
 import { buildFileMetadata } from '../video-file'
 import { VideoPathManager } from '../video-path-manager'
 import { buildFFmpegVOD } from './shared'
@@ -62,10 +63,10 @@ export async function optimizeOriginalVideofile (options: {
      // Important to do this before getVideoFilename() to take in account the new filename
      inputVideoFile.resolution = resolution
      inputVideoFile.extname = newExtname
-      inputVideoFile.filename = generateWebTorrentVideoFilename(resolution, newExtname)
+      inputVideoFile.filename = generateWebVideoFilename(resolution, newExtname)
      inputVideoFile.storage = VideoStorage.FILE_SYSTEM
-      const { videoFile } = await onWebTorrentVideoFileTranscoding({
+      const { videoFile } = await onWebVideoFileTranscoding({
        video,
        videoFile: inputVideoFile,
        videoOutputPath
@@ -82,8 +83,8 @@ export async function optimizeOriginalVideofile (options: {
  }
 }
-// Transcode the original video file to a lower resolution compatible with WebTorrent
+// Transcode the original video file to a lower resolution compatible with web browsers
-export async function transcodeNewWebTorrentResolution (options: {
+export async function transcodeNewWebVideoResolution (options: {
  video: MVideoFullLight
  resolution: VideoResolution
  fps: number
@@ -104,7 +105,7 @@ export async function transcodeNewWebTorrentResolution (options: {
      const newVideoFile = new VideoFileModel({
        resolution,
        extname: newExtname,
-        filename: generateWebTorrentVideoFilename(resolution, newExtname),
+        filename: generateWebVideoFilename(resolution, newExtname),
        size: 0,
        videoId: video.id
      })
@@ -125,7 +126,7 @@ export async function transcodeNewWebTorrentResolution (options: {
      await buildFFmpegVOD(job).transcode(transcodeOptions)
-      return onWebTorrentVideoFileTranscoding({ video, videoFile: newVideoFile, videoOutputPath })
+      return onWebVideoFileTranscoding({ video, videoFile: newVideoFile, videoOutputPath })
    })
    return result
@@ -188,17 +189,18 @@ export async function mergeAudioVideofile (options: {
      // Important to do this before getVideoFilename() to take in account the new file extension
      inputVideoFile.extname = newExtname
      inputVideoFile.resolution = resolution
-      inputVideoFile.filename = generateWebTorrentVideoFilename(inputVideoFile.resolution, newExtname)
+      inputVideoFile.filename = generateWebVideoFilename(inputVideoFile.resolution, newExtname)
      // ffmpeg generated a new video file, so update the video duration
      // See https://trac.ffmpeg.org/ticket/5456
      video.duration = await getVideoStreamDuration(videoOutputPath)
      await video.save()
-      return onWebTorrentVideoFileTranscoding({
+      return onWebVideoFileTranscoding({
        video,
        videoFile: inputVideoFile,
-        videoOutputPath
+        videoOutputPath,
+        wasAudioFile: true
      })
    })
@@ -208,12 +210,13 @@ export async function mergeAudioVideofile (options: {
  }
 }
-export async function onWebTorrentVideoFileTranscoding (options: {
+export async function onWebVideoFileTranscoding (options: {
  video: MVideoFullLight
  videoFile: MVideoFile
  videoOutputPath: string
+  wasAudioFile?: boolean // default false
 }) {
-  const { video, videoFile, videoOutputPath } = options
+  const { video, videoFile, videoOutputPath, wasAudioFile } = options
  const mutexReleaser = await VideoPathManager.Instance.lockFiles(video.uuid)
@@ -236,12 +239,23 @@ export async function onWebTorrentVideoFileTranscoding (options: {
    await createTorrentAndSetInfoHash(video, videoFile)
-    const oldFile = await VideoFileModel.loadWebTorrentFile({ videoId: video.id, fps: videoFile.fps, resolution: videoFile.resolution })
+    const oldFile = await VideoFileModel.loadWebVideoFile({ videoId: video.id, fps: videoFile.fps, resolution: videoFile.resolution })
-    if (oldFile) await video.removeWebTorrentFile(oldFile)
+    if (oldFile) await video.removeWebVideoFile(oldFile)
    await VideoFileModel.customUpsert(videoFile, 'video', undefined)
    video.VideoFiles = await video.$get('VideoFiles')
+    if (wasAudioFile) {
+      await JobQueue.Instance.createJob({
+        type: 'generate-video-storyboard' as 'generate-video-storyboard',
+        payload: {
+          videoUUID: video.uuid,
+          // No need to federate, we process these jobs sequentially
+          federate: false
+        }
+      })
+    }
    return { video, videoFile }
  } finally {
    mutexReleaser()
diff --git a/server/lib/video-file.ts b/server/lib/video-file.ts
index 88d48c945..46af67ccd 100644
--- a/server/lib/video-file.ts
+++ b/server/lib/video-file.ts
@@ -7,7 +7,7 @@ import { getFileSize } from '@shared/extra-utils'
 import { ffprobePromise, getVideoStreamDimensionsInfo, getVideoStreamFPS, isAudioFile } from '@shared/ffmpeg'
 import { VideoFileMetadata, VideoResolution } from '@shared/models'
 import { lTags } from './object-storage/shared'
-import { generateHLSVideoFilename, generateWebTorrentVideoFilename } from './paths'
+import { generateHLSVideoFilename, generateWebVideoFilename } from './paths'
 import { VideoPathManager } from './video-path-manager'
 async function buildNewFile (options: {
@@ -33,7 +33,7 @@ async function buildNewFile (options: {
  }
  videoFile.filename = mode === 'web-video'
-    ? generateWebTorrentVideoFilename(videoFile.resolution, videoFile.extname)
+    ? generateWebVideoFilename(videoFile.resolution, videoFile.extname)
    : generateHLSVideoFilename(videoFile.resolution)
  return videoFile
@@ -85,12 +85,12 @@ async function removeHLSFile (video: MVideoWithAllFiles, fileToDeleteId: number)
 // ---------------------------------------------------------------------------
-async function removeAllWebTorrentFiles (video: MVideoWithAllFiles) {
+async function removeAllWebVideoFiles (video: MVideoWithAllFiles) {
  const videoFileMutexReleaser = await VideoPathManager.Instance.lockFiles(video.uuid)
  try {
    for (const file of video.VideoFiles) {
-      await video.removeWebTorrentFile(file)
+      await video.removeWebVideoFile(file)
      await file.destroy()
    }
@@ -102,17 +102,17 @@ async function removeAllWebTorrentFiles (video: MVideoWithAllFiles) {
  return video
 }
-async function removeWebTorrentFile (video: MVideoWithAllFiles, fileToDeleteId: number) {
+async function removeWebVideoFile (video: MVideoWithAllFiles, fileToDeleteId: number) {
  const files = video.VideoFiles
  if (files.length === 1) {
-    return removeAllWebTorrentFiles(video)
+    return removeAllWebVideoFiles(video)
  }
  const videoFileMutexReleaser = await VideoPathManager.Instance.lockFiles(video.uuid)
  try {
    const toDelete = files.find(f => f.id === fileToDeleteId)
-    await video.removeWebTorrentFile(toDelete)
+    await video.removeWebVideoFile(toDelete)
    await toDelete.destroy()
    video.VideoFiles = files.filter(f => f.id !== toDelete.id)
@@ -138,8 +138,8 @@ export {
  removeHLSPlaylist,
  removeHLSFile,
-  removeAllWebTorrentFiles,
+  removeAllWebVideoFiles,
-  removeWebTorrentFile,
+  removeWebVideoFile,
  buildFileMetadata
 }
diff --git a/server/lib/video-path-manager.ts b/server/lib/video-path-manager.ts
index 9953cae5d..133544bb2 100644
--- a/server/lib/video-path-manager.ts
+++ b/server/lib/video-path-manager.ts
@@ -8,7 +8,7 @@ import { DIRECTORIES } from '@server/initializers/constants'
 import { MStreamingPlaylistVideo, MVideo, MVideoFile, MVideoFileStreamingPlaylistVideo, MVideoFileVideo } from '@server/types/models'
 import { buildUUID } from '@shared/extra-utils'
 import { VideoStorage } from '@shared/models'
-import { makeHLSFileAvailable, makeWebTorrentFileAvailable } from './object-storage'
+import { makeHLSFileAvailable, makeWebVideoFileAvailable } from './object-storage'
 import { getHLSDirectory, getHLSRedundancyDirectory, getHlsResolutionPlaylistFilename } from './paths'
 import { isVideoInPrivateDirectory } from './video-privacy'
@@ -78,7 +78,7 @@ class VideoPathManager {
    }
    return this.makeAvailableFactory(
-      () => makeWebTorrentFileAvailable(videoFile.filename, destination),
+      () => makeWebVideoFileAvailable(videoFile.filename, destination),
      true,
      cb
    )
diff --git a/server/lib/video-pre-import.ts b/server/lib/video-pre-import.ts
index df67dc953..381f1f535 100644
--- a/server/lib/video-pre-import.ts
+++ b/server/lib/video-pre-import.ts
@@ -29,7 +29,8 @@ import {
 } from '@server/types/models'
 import { ThumbnailType, VideoImportCreate, VideoImportPayload, VideoImportState, VideoPrivacy, VideoState } from '@shared/models'
 import { getLocalVideoActivityPubUrl } from './activitypub/url'
-import { updateVideoMiniatureFromExisting, updateVideoMiniatureFromUrl } from './thumbnail'
+import { updateLocalVideoMiniatureFromExisting, updateLocalVideoMiniatureFromUrl } from './thumbnail'
+import { VideoPasswordModel } from '@server/models/video/video-password'
 class YoutubeDlImportError extends Error {
  code: YoutubeDlImportError.CODE
@@ -64,8 +65,9 @@ async function insertFromImportIntoDB (parameters: {
  tags: string[]
  videoImportAttributes: FilteredModelAttributes<VideoImportModel>
  user: MUser
+  videoPasswords?: string[]
 }): Promise<MVideoImportFormattable> {
-  const { video, thumbnailModel, previewModel, videoChannel, tags, videoImportAttributes, user } = parameters
+  const { video, thumbnailModel, previewModel, videoChannel, tags, videoImportAttributes, user, videoPasswords } = parameters
  const videoImport = await sequelizeTypescript.transaction(async t => {
    const sequelizeOptions = { transaction: t }
@@ -77,6 +79,10 @@ async function insertFromImportIntoDB (parameters: {
    if (thumbnailModel) await videoCreated.addAndSaveThumbnail(thumbnailModel, t)
    if (previewModel) await videoCreated.addAndSaveThumbnail(previewModel, t)
+    if (videoCreated.privacy === VideoPrivacy.PASSWORD_PROTECTED) {
+      await VideoPasswordModel.addPasswords(videoPasswords, video.id, t)
+    }
    await autoBlacklistVideoIfNeeded({
      video: videoCreated,
      user,
@@ -208,7 +214,8 @@ async function buildYoutubeDLImport (options: {
      state: VideoImportState.PENDING,
      userId: user.id,
      videoChannelSyncId: channelSync?.id
-    }
+    },
+    videoPasswords: importDataOverride.videoPasswords
  })
  // Get video subtitles
@@ -249,19 +256,22 @@ async function forgeThumbnail ({ inputPath, video, downloadUrl, type }: {
  type: ThumbnailType
 }): Promise<MThumbnail> {
  if (inputPath) {
-    return updateVideoMiniatureFromExisting({
+    return updateLocalVideoMiniatureFromExisting({
      inputPath,
      video,
      type,
      automaticallyGenerated: false
    })
-  } else if (downloadUrl) {
+  }
+  if (downloadUrl) {
    try {
-      return await updateVideoMiniatureFromUrl({ downloadUrl, video, type })
+      return await updateLocalVideoMiniatureFromUrl({ downloadUrl, video, type })
    } catch (err) {
      logger.warn('Cannot process thumbnail %s from youtube-dl.', downloadUrl, { err })
    }
  }
  return null
 }
diff --git a/server/lib/video-privacy.ts b/server/lib/video-privacy.ts
index 41f9d62b3..5dd4d9781 100644
--- a/server/lib/video-privacy.ts
+++ b/server/lib/video-privacy.ts
@@ -4,7 +4,13 @@ import { logger } from '@server/helpers/logger'
 import { DIRECTORIES } from '@server/initializers/constants'
 import { MVideo, MVideoFile, MVideoFullLight } from '@server/types/models'
 import { VideoPrivacy, VideoStorage } from '@shared/models'
-import { updateHLSFilesACL, updateWebTorrentFileACL } from './object-storage'
+import { updateHLSFilesACL, updateWebVideoFileACL } from './object-storage'
+const validPrivacySet = new Set([
+  VideoPrivacy.PRIVATE,
+  VideoPrivacy.INTERNAL,
+  VideoPrivacy.PASSWORD_PROTECTED
+])
 function setVideoPrivacy (video: MVideo, newPrivacy: VideoPrivacy) {
  if (video.privacy === VideoPrivacy.PRIVATE && newPrivacy !== VideoPrivacy.PRIVATE) {
@@ -14,8 +20,8 @@ function setVideoPrivacy (video: MVideo, newPrivacy: VideoPrivacy) {
  video.privacy = newPrivacy
 }
-function isVideoInPrivateDirectory (privacy: VideoPrivacy) {
+function isVideoInPrivateDirectory (privacy) {
-  return privacy === VideoPrivacy.PRIVATE || privacy === VideoPrivacy.INTERNAL
+  return validPrivacySet.has(privacy)
 }
 function isVideoInPublicDirectory (privacy: VideoPrivacy) {
@@ -61,9 +67,9 @@ async function moveFiles (options: {
  for (const file of video.VideoFiles) {
    if (file.storage === VideoStorage.FILE_SYSTEM) {
-      await moveWebTorrentFileOnFS(type, video, file)
+      await moveWebVideoFileOnFS(type, video, file)
    } else {
-      await updateWebTorrentFileACL(video, file)
+      await updateWebVideoFileACL(video, file)
    }
  }
@@ -78,22 +84,22 @@ async function moveFiles (options: {
  }
 }
-async function moveWebTorrentFileOnFS (type: MoveType, video: MVideo, file: MVideoFile) {
+async function moveWebVideoFileOnFS (type: MoveType, video: MVideo, file: MVideoFile) {
-  const directories = getWebTorrentDirectories(type)
+  const directories = getWebVideoDirectories(type)
  const source = join(directories.old, file.filename)
  const destination = join(directories.new, file.filename)
  try {
-    logger.info('Moving WebTorrent files of %s after privacy change (%s -> %s).', video.uuid, source, destination)
+    logger.info('Moving web video files of %s after privacy change (%s -> %s).', video.uuid, source, destination)
    await move(source, destination)
  } catch (err) {
-    logger.error('Cannot move webtorrent file %s to %s after privacy change', source, destination, { err })
+    logger.error('Cannot move web video file %s to %s after privacy change', source, destination, { err })
  }
 }
-function getWebTorrentDirectories (moveType: MoveType) {
+function getWebVideoDirectories (moveType: MoveType) {
  if (moveType === 'private-to-public') {
    return { old: DIRECTORIES.VIDEOS.PRIVATE, new: DIRECTORIES.VIDEOS.PUBLIC }
  }
diff --git a/server/lib/video-studio.ts b/server/lib/video-studio.ts
index 0d3db8f60..f549a7084 100644
--- a/server/lib/video-studio.ts
+++ b/server/lib/video-studio.ts
@@ -12,7 +12,7 @@ import { JobQueue } from './job-queue'
 import { VideoStudioTranscodingJobHandler } from './runners'
 import { createOptimizeOrMergeAudioJobs } from './transcoding/create-transcoding-job'
 import { getTranscodingJobPriority } from './transcoding/transcoding-priority'
-import { buildNewFile, removeHLSPlaylist, removeWebTorrentFile } from './video-file'
+import { buildNewFile, removeHLSPlaylist, removeWebVideoFile } from './video-file'
 import { VideoPathManager } from './video-path-manager'
 const lTags = loggerTagsFactory('video-studio')
@@ -119,12 +119,12 @@ export async function onVideoStudioEnded (options: {
 // Private
 // ---------------------------------------------------------------------------
-async function removeAllFiles (video: MVideoWithAllFiles, webTorrentFileException: MVideoFile) {
+async function removeAllFiles (video: MVideoWithAllFiles, webVideoFileException: MVideoFile) {
  await removeHLSPlaylist(video)
  for (const file of video.VideoFiles) {
-    if (file.id === webTorrentFileException.id) continue
+    if (file.id === webVideoFileException.id) continue
-    await removeWebTorrentFile(video, file.id)
+    await removeWebVideoFile(video, file.id)
  }
 }
diff --git a/server/lib/video-tokens-manager.ts b/server/lib/video-tokens-manager.ts
index 660533528..e28e55cf7 100644
--- a/server/lib/video-tokens-manager.ts
+++ b/server/lib/video-tokens-manager.ts
@@ -12,26 +12,34 @@ class VideoTokensManager {
  private static instance: VideoTokensManager
-  private readonly lruCache = new LRUCache<string, { videoUUID: string, user: MUserAccountUrl }>({
+  private readonly lruCache = new LRUCache<string, { videoUUID: string, user?: MUserAccountUrl }>({
    max: LRU_CACHE.VIDEO_TOKENS.MAX_SIZE,
    ttl: LRU_CACHE.VIDEO_TOKENS.TTL
  })
  private constructor () {}
-  create (options: {
+  createForAuthUser (options: {
    user: MUserAccountUrl
    videoUUID: string
  }) {
-    const token = buildUUID()
+    const { token, expires } = this.generateVideoToken()
-    const expires = new Date(new Date().getTime() + LRU_CACHE.VIDEO_TOKENS.TTL)
    this.lruCache.set(token, pick(options, [ 'user', 'videoUUID' ]))
    return { token, expires }
  }
+  createForPasswordProtectedVideo (options: {
+    videoUUID: string
+  }) {
+    const { token, expires } = this.generateVideoToken()
+    this.lruCache.set(token, pick(options, [ 'videoUUID' ]))
+    return { token, expires }
+  }
  hasToken (options: {
    token: string
    videoUUID: string
@@ -54,6 +62,13 @@ class VideoTokensManager {
  static get Instance () {
    return this.instance || (this.instance = new this())
  }
+  private generateVideoToken () {
+    const token = buildUUID()
+    const expires = new Date(new Date().getTime() + LRU_CACHE.VIDEO_TOKENS.TTL)
+    return { token, expires }
+  }
 }
 // ---------------------------------------------------------------------------
diff --git a/server/lib/video-urls.ts b/server/lib/video-urls.ts
index 64c2c9bf9..0597488ad 100644
--- a/server/lib/video-urls.ts
+++ b/server/lib/video-urls.ts
@@ -9,7 +9,7 @@ function generateHLSRedundancyUrl (video: MVideo, playlist: MStreamingPlaylist)
  return WEBSERVER.URL + STATIC_PATHS.REDUNDANCY + playlist.getStringType() + '/' + video.uuid
 }
-function generateWebTorrentRedundancyUrl (file: MVideoFile) {
+function generateWebVideoRedundancyUrl (file: MVideoFile) {
  return WEBSERVER.URL + STATIC_PATHS.REDUNDANCY + file.filename
 }
@@ -26,6 +26,6 @@ function getLocalVideoFileMetadataUrl (video: MVideoUUID, videoFile: MVideoFile)
 export {
  getLocalVideoFileMetadataUrl,
-  generateWebTorrentRedundancyUrl,
+  generateWebVideoRedundancyUrl,
  generateHLSRedundancyUrl
 }
diff --git a/server/lib/video.ts b/server/lib/video.ts
index 588dc553f..362c861a5 100644
--- a/server/lib/video.ts
+++ b/server/lib/video.ts
@@ -10,7 +10,7 @@ import { FilteredModelAttributes } from '@server/types'
 import { MThumbnail, MVideoFullLight, MVideoTag, MVideoThumbnail, MVideoUUID } from '@server/types/models'
 import { ManageVideoTorrentPayload, ThumbnailType, VideoCreate, VideoPrivacy, VideoState } from '@shared/models'
 import { CreateJobArgument, JobQueue } from './job-queue/job-queue'
-import { updateVideoMiniatureFromExisting } from './thumbnail'
+import { updateLocalVideoMiniatureFromExisting } from './thumbnail'
 import { moveFilesIfPrivacyChanged } from './video-privacy'
 function buildLocalVideoFromReq (videoInfo: VideoCreate, channelId: number): FilteredModelAttributes<VideoModel> {
@@ -55,7 +55,7 @@ async function buildVideoThumbnailsFromReq (options: {
    const fields = files?.[p.fieldName]
    if (fields) {
-      return updateVideoMiniatureFromExisting({
+      return updateLocalVideoMiniatureFromExisting({
        inputPath: fields[0].path,
        video,
        type: p.type,
diff --git a/server/lib/worker/workers/image-downloader.ts b/server/lib/worker/workers/image-downloader.ts
index 4b32f723e..209594589 100644
--- a/server/lib/worker/workers/image-downloader.ts
+++ b/server/lib/worker/workers/image-downloader.ts
@@ -24,6 +24,8 @@ async function downloadImage (options: {
    throw err
  }
+  return destPath
 }
 module.exports = downloadImage