235 files changed, 5468 insertions, 2220 deletions

diff --git a/server/controllers/activitypub/client.ts b/server/controllers/activitypub/client.ts
index 750e3091c..c47c61f52 100644
--- a/server/controllers/activitypub/client.ts
+++ b/server/controllers/activitypub/client.ts
@@ -4,6 +4,7 @@ import { activityPubCollectionPagination } from '@server/lib/activitypub/collect
 import { activityPubContextify } from '@server/lib/activitypub/context'
 import { getServerActor } from '@server/models/application/application'
 import { MAccountId, MActorId, MChannelId, MVideoId } from '@server/types/models'
+import { VideoCommentObject } from '@shared/models'
 import { VideoPrivacy, VideoRateType } from '../../../shared/models/videos'
 import { VideoPlaylistPrivacy } from '../../../shared/models/videos/playlist/video-playlist-privacy.model'
 import { ROUTE_CACHE_LIFETIME, WEBSERVER } from '../../initializers/constants'
@@ -33,7 +34,6 @@ import { videoPlaylistElementAPGetValidator, videoPlaylistsGetValidator } from '
 import { AccountModel } from '../../models/account/account'
 import { AccountVideoRateModel } from '../../models/account/account-video-rate'
 import { ActorFollowModel } from '../../models/actor/actor-follow'
-import { VideoCaptionModel } from '../../models/video/video-caption'
 import { VideoCommentModel } from '../../models/video/video-comment'
 import { VideoPlaylistModel } from '../../models/video/video-playlist'
 import { VideoShareModel } from '../../models/video/video-share'
@@ -242,14 +242,13 @@ async function videoController (req: express.Request, res: express.Response) {
   if (redirectIfNotOwned(video.url, res)) return
 
   // We need captions to render AP object
-  const captions = await VideoCaptionModel.listVideoCaptions(video.id)
-  const videoWithCaptions = Object.assign(video, { VideoCaptions: captions })
+  const videoAP = await video.lightAPToFullAP(undefined)
 
-  const audience = getAudience(videoWithCaptions.VideoChannel.Account.Actor, videoWithCaptions.privacy === VideoPrivacy.PUBLIC)
-  const videoObject = audiencify(await videoWithCaptions.toActivityPubObject(), audience)
+  const audience = getAudience(videoAP.VideoChannel.Account.Actor, videoAP.privacy === VideoPrivacy.PUBLIC)
+  const videoObject = audiencify(await videoAP.toActivityPubObject(), audience)
 
   if (req.path.endsWith('/activity')) {
-    const data = buildCreateActivity(videoWithCaptions.url, video.VideoChannel.Account.Actor, videoObject, audience)
+    const data = buildCreateActivity(videoAP.url, video.VideoChannel.Account.Actor, videoObject, audience)
     return activityPubResponse(activityPubContextify(data, 'Video'), res)
   }
 
@@ -355,7 +354,7 @@ async function videoCommentController (req: express.Request, res: express.Respon
     videoCommentObject = audiencify(videoCommentObject, audience)
 
     if (req.path.endsWith('/activity')) {
-      const data = buildCreateActivity(videoComment.url, videoComment.Account.Actor, videoCommentObject, audience)
+      const data = buildCreateActivity(videoComment.url, videoComment.Account.Actor, videoCommentObject as VideoCommentObject, audience)
       return activityPubResponse(activityPubContextify(data, 'Comment'), res)
     }
   }
diff --git a/server/controllers/activitypub/outbox.ts b/server/controllers/activitypub/outbox.ts
index 681a5660c..4175cf276 100644
--- a/server/controllers/activitypub/outbox.ts
+++ b/server/controllers/activitypub/outbox.ts
@@ -63,6 +63,7 @@ async function buildActivities (actor: MActorLight, start: number, count: number
 
       activities.push(announceActivity)
     } else {
+      // FIXME: only use the video URL to reduce load. Breaks compat with PeerTube < 6.0.0
       const videoObject = await video.toActivityPubObject()
       const createActivity = buildCreateActivity(video.url, byActor, videoObject, createActivityAudience)
 
diff --git a/server/controllers/api/accounts.ts b/server/controllers/api/accounts.ts
index 96f36bf6f..49cd7559a 100644
--- a/server/controllers/api/accounts.ts
+++ b/server/controllers/api/accounts.ts
@@ -2,7 +2,6 @@ import express from 'express'
 import { pickCommonVideoQuery } from '@server/helpers/query'
 import { ActorFollowModel } from '@server/models/actor/actor-follow'
 import { getServerActor } from '@server/models/application/application'
-import { guessAdditionalAttributesFromQuery } from '@server/models/video/formatter/video-format-utils'
 import { VideoChannelSyncModel } from '@server/models/video/video-channel-sync'
 import { buildNSFWFilter, getCountVideos, isUserAbleToSearchRemoteURI } from '../../helpers/express-utils'
 import { getFormattedObjects } from '../../helpers/utils'
@@ -36,6 +35,7 @@ import {
 import { commonVideoPlaylistFiltersValidator, videoPlaylistsSearchValidator } from '../../middlewares/validators/videos/video-playlists'
 import { AccountModel } from '../../models/account/account'
 import { AccountVideoRateModel } from '../../models/account/account-video-rate'
+import { guessAdditionalAttributesFromQuery } from '../../models/video/formatter'
 import { VideoModel } from '../../models/video/video'
 import { VideoChannelModel } from '../../models/video/video-channel'
 import { VideoPlaylistModel } from '../../models/video/video-playlist'
diff --git a/server/controllers/api/config.ts b/server/controllers/api/config.ts
index 228eae109..0980ec10a 100644
--- a/server/controllers/api/config.ts
+++ b/server/controllers/api/config.ts
@@ -190,6 +190,9 @@ function customConfig (): CustomConfig {
       },
       torrents: {
         size: CONFIG.CACHE.TORRENTS.SIZE
+      },
+      storyboards: {
+        size: CONFIG.CACHE.STORYBOARDS.SIZE
       }
     },
     signup: {
@@ -239,8 +242,8 @@ function customConfig (): CustomConfig {
         '2160p': CONFIG.TRANSCODING.RESOLUTIONS['2160p']
       },
       alwaysTranscodeOriginalResolution: CONFIG.TRANSCODING.ALWAYS_TRANSCODE_ORIGINAL_RESOLUTION,
-      webtorrent: {
-        enabled: CONFIG.TRANSCODING.WEBTORRENT.ENABLED
+      webVideos: {
+        enabled: CONFIG.TRANSCODING.WEB_VIDEOS.ENABLED
       },
       hls: {
         enabled: CONFIG.TRANSCODING.HLS.ENABLED
diff --git a/server/controllers/api/index.ts b/server/controllers/api/index.ts
index 31f1a56f9..38bd135d0 100644
--- a/server/controllers/api/index.ts
+++ b/server/controllers/api/index.ts
@@ -1,8 +1,7 @@
 import cors from 'cors'
 import express from 'express'
-
+import { logger } from '@server/helpers/logger'
 import { HttpStatusCode } from '../../../shared/models'
-import { badRequest } from '../../helpers/express-utils'
 import { abuseRouter } from './abuse'
 import { accountsRouter } from './accounts'
 import { blocklistRouter } from './blocklist'
@@ -64,3 +63,11 @@ export { apiRouter }
 function pong (req: express.Request, res: express.Response) {
   return res.send('pong').status(HttpStatusCode.OK_200).end()
 }
+
+function badRequest (req: express.Request, res: express.Response) {
+  logger.debug(`API express handler not found: bad PeerTube request for ${req.method} - ${req.originalUrl}`)
+
+  return res.type('json')
+    .status(HttpStatusCode.BAD_REQUEST_400)
+    .end()
+}
diff --git a/server/controllers/api/runners/jobs-files.ts b/server/controllers/api/runners/jobs-files.ts
index 4e69fb902..cb4eff570 100644
--- a/server/controllers/api/runners/jobs-files.ts
+++ b/server/controllers/api/runners/jobs-files.ts
@@ -1,6 +1,6 @@
 import express from 'express'
 import { logger, loggerTagsFactory } from '@server/helpers/logger'
-import { proxifyHLS, proxifyWebTorrentFile } from '@server/lib/object-storage'
+import { proxifyHLS, proxifyWebVideoFile } from '@server/lib/object-storage'
 import { VideoPathManager } from '@server/lib/video-path-manager'
 import { getStudioTaskFilePath } from '@server/lib/video-studio'
 import { apiRateLimiter, asyncMiddleware } from '@server/middlewares'
@@ -70,7 +70,7 @@ async function getMaxQualityVideoFile (req: express.Request, res: express.Respon
     }
 
     // Web video
-    return proxifyWebTorrentFile({
+    return proxifyWebVideoFile({
       req,
       res,
       filename: file.filename
diff --git a/server/controllers/api/search/search-videos.ts b/server/controllers/api/search/search-videos.ts
index 1d7a7b7bc..034a63ace 100644
--- a/server/controllers/api/search/search-videos.ts
+++ b/server/controllers/api/search/search-videos.ts
@@ -8,7 +8,6 @@ import { getOrCreateAPVideo } from '@server/lib/activitypub/videos'
 import { Hooks } from '@server/lib/plugins/hooks'
 import { buildMutedForSearchIndex, isSearchIndexSearch, isURISearch } from '@server/lib/search'
 import { getServerActor } from '@server/models/application/application'
-import { guessAdditionalAttributesFromQuery } from '@server/models/video/formatter/video-format-utils'
 import { HttpStatusCode, ResultList, Video } from '@shared/models'
 import { VideosSearchQueryAfterSanitize } from '../../../../shared/models/search'
 import { buildNSFWFilter, isUserAbleToSearchRemoteURI } from '../../../helpers/express-utils'
@@ -25,6 +24,7 @@ import {
   videosSearchSortValidator,
   videosSearchValidator
 } from '../../../middlewares'
+import { guessAdditionalAttributesFromQuery } from '../../../models/video/formatter'
 import { VideoModel } from '../../../models/video/video'
 import { MVideoAccountLightBlacklistAllFiles } from '../../../types/models'
 import { searchLocalUrl } from './shared'
diff --git a/server/controllers/api/users/me.ts b/server/controllers/api/users/me.ts
index 218091d91..4753308e8 100644
--- a/server/controllers/api/users/me.ts
+++ b/server/controllers/api/users/me.ts
@@ -213,19 +213,14 @@ async function updateMe (req: express.Request, res: express.Response) {
     'noInstanceConfigWarningModal',
     'noAccountSetupWarningModal',
     'noWelcomeModal',
-    'emailPublic'
+    'emailPublic',
+    'p2pEnabled'
   ]
 
   for (const key of keysToUpdate) {
     if (body[key] !== undefined) user.set(key, body[key])
   }
 
-  if (body.p2pEnabled !== undefined) {
-    user.set('p2pEnabled', body.p2pEnabled)
-  } else if (body.webTorrentEnabled !== undefined) { // FIXME: deprecated in 4.1
-    user.set('p2pEnabled', body.webTorrentEnabled)
-  }
-
   if (body.email !== undefined) {
     if (CONFIG.SIGNUP.REQUIRES_EMAIL_VERIFICATION) {
       user.pendingEmail = body.email
diff --git a/server/controllers/api/users/my-subscriptions.ts b/server/controllers/api/users/my-subscriptions.ts
index 6e2aa3711..c4360f59d 100644
--- a/server/controllers/api/users/my-subscriptions.ts
+++ b/server/controllers/api/users/my-subscriptions.ts
@@ -3,7 +3,7 @@ import express from 'express'
 import { handlesToNameAndHost } from '@server/helpers/actors'
 import { pickCommonVideoQuery } from '@server/helpers/query'
 import { sendUndoFollow } from '@server/lib/activitypub/send'
-import { guessAdditionalAttributesFromQuery } from '@server/models/video/formatter/video-format-utils'
+import { Hooks } from '@server/lib/plugins/hooks'
 import { VideoChannelModel } from '@server/models/video/video-channel'
 import { HttpStatusCode } from '../../../../shared/models/http/http-error-codes'
 import { buildNSFWFilter, getCountVideos } from '../../../helpers/express-utils'
@@ -29,8 +29,8 @@ import {
   videosSortValidator
 } from '../../../middlewares/validators'
 import { ActorFollowModel } from '../../../models/actor/actor-follow'
+import { guessAdditionalAttributesFromQuery } from '../../../models/video/formatter'
 import { VideoModel } from '../../../models/video/video'
-import { Hooks } from '@server/lib/plugins/hooks'
 
 const mySubscriptionsRouter = express.Router()
 
diff --git a/server/controllers/api/video-channel.ts b/server/controllers/api/video-channel.ts
index cdafa31dc..3d7ef31ee 100644
--- a/server/controllers/api/video-channel.ts
+++ b/server/controllers/api/video-channel.ts
@@ -4,7 +4,6 @@ import { getBiggestActorImage } from '@server/lib/actor-image'
 import { Hooks } from '@server/lib/plugins/hooks'
 import { ActorFollowModel } from '@server/models/actor/actor-follow'
 import { getServerActor } from '@server/models/application/application'
-import { guessAdditionalAttributesFromQuery } from '@server/models/video/formatter/video-format-utils'
 import { MChannelBannerAccountDefault } from '@server/types/models'
 import { ActorImageType, HttpStatusCode, VideoChannelCreate, VideoChannelUpdate, VideosImportInChannelCreate } from '@shared/models'
 import { auditLoggerFactory, getAuditIdFromRes, VideoChannelAuditView } from '../../helpers/audit-logger'
@@ -48,6 +47,7 @@ import {
 import { updateAvatarValidator, updateBannerValidator } from '../../middlewares/validators/actor-image'
 import { commonVideoPlaylistFiltersValidator } from '../../middlewares/validators/videos/video-playlists'
 import { AccountModel } from '../../models/account/account'
+import { guessAdditionalAttributesFromQuery } from '../../models/video/formatter'
 import { VideoModel } from '../../models/video/video'
 import { VideoChannelModel } from '../../models/video/video-channel'
 import { VideoPlaylistModel } from '../../models/video/video-playlist'
diff --git a/server/controllers/api/video-playlist.ts b/server/controllers/api/video-playlist.ts
index fe00034ed..73362e1e3 100644
--- a/server/controllers/api/video-playlist.ts
+++ b/server/controllers/api/video-playlist.ts
@@ -1,6 +1,6 @@
 import express from 'express'
-import { join } from 'path'
 import { scheduleRefreshIfNeeded } from '@server/lib/activitypub/playlists'
+import { VideoMiniaturePermanentFileCache } from '@server/lib/files-cache'
 import { Hooks } from '@server/lib/plugins/hooks'
 import { getServerActor } from '@server/models/application/application'
 import { MVideoPlaylistFull, MVideoPlaylistThumbnail, MVideoThumbnail } from '@server/types/models'
@@ -18,12 +18,11 @@ import { resetSequelizeInstance } from '../../helpers/database-utils'
 import { createReqFiles } from '../../helpers/express-utils'
 import { logger } from '../../helpers/logger'
 import { getFormattedObjects } from '../../helpers/utils'
-import { CONFIG } from '../../initializers/config'
 import { MIMETYPES, VIDEO_PLAYLIST_PRIVACIES } from '../../initializers/constants'
 import { sequelizeTypescript } from '../../initializers/database'
 import { sendCreateVideoPlaylist, sendDeleteVideoPlaylist, sendUpdateVideoPlaylist } from '../../lib/activitypub/send'
 import { getLocalVideoPlaylistActivityPubUrl, getLocalVideoPlaylistElementActivityPubUrl } from '../../lib/activitypub/url'
-import { updatePlaylistMiniatureFromExisting } from '../../lib/thumbnail'
+import { updateLocalPlaylistMiniatureFromExisting } from '../../lib/thumbnail'
 import {
   apiRateLimiter,
   asyncMiddleware,
@@ -178,7 +177,7 @@ async function addVideoPlaylist (req: express.Request, res: express.Response) {
 
   const thumbnailField = req.files['thumbnailfile']
   const thumbnailModel = thumbnailField
-    ? await updatePlaylistMiniatureFromExisting({
+    ? await updateLocalPlaylistMiniatureFromExisting({
       inputPath: thumbnailField[0].path,
       playlist: videoPlaylist,
       automaticallyGenerated: false
@@ -220,7 +219,7 @@ async function updateVideoPlaylist (req: express.Request, res: express.Response)
 
   const thumbnailField = req.files['thumbnailfile']
   const thumbnailModel = thumbnailField
-    ? await updatePlaylistMiniatureFromExisting({
+    ? await updateLocalPlaylistMiniatureFromExisting({
       inputPath: thumbnailField[0].path,
       playlist: videoPlaylistInstance,
       automaticallyGenerated: false
@@ -496,8 +495,13 @@ async function generateThumbnailForPlaylist (videoPlaylist: MVideoPlaylistThumbn
     return
   }
 
-  const inputPath = join(CONFIG.STORAGE.THUMBNAILS_DIR, videoMiniature.filename)
-  const thumbnailModel = await updatePlaylistMiniatureFromExisting({
+  // Ensure the file is on disk
+  const videoMiniaturePermanentFileCache = new VideoMiniaturePermanentFileCache()
+  const inputPath = videoMiniature.isOwned()
+    ? videoMiniature.getPath()
+    : await videoMiniaturePermanentFileCache.downloadRemoteFile(videoMiniature)
+
+  const thumbnailModel = await updateLocalPlaylistMiniatureFromExisting({
     inputPath,
     playlist: videoPlaylist,
     automaticallyGenerated: true,
diff --git a/server/controllers/api/videos/files.ts b/server/controllers/api/videos/files.ts
index 6d9c0b843..67b60ff63 100644
--- a/server/controllers/api/videos/files.ts
+++ b/server/controllers/api/videos/files.ts
@@ -2,7 +2,8 @@ import express from 'express'
 import toInt from 'validator/lib/toInt'
 import { logger, loggerTagsFactory } from '@server/helpers/logger'
 import { federateVideoIfNeeded } from '@server/lib/activitypub/videos'
-import { removeAllWebTorrentFiles, removeHLSFile, removeHLSPlaylist, removeWebTorrentFile } from '@server/lib/video-file'
+import { updatePlaylistAfterFileChange } from '@server/lib/hls'
+import { removeAllWebVideoFiles, removeHLSFile, removeHLSPlaylist, removeWebVideoFile } from '@server/lib/video-file'
 import { VideoFileModel } from '@server/models/video/video-file'
 import { HttpStatusCode, UserRight } from '@shared/models'
 import {
@@ -12,11 +13,10 @@ import {
   videoFileMetadataGetValidator,
   videoFilesDeleteHLSFileValidator,
   videoFilesDeleteHLSValidator,
-  videoFilesDeleteWebTorrentFileValidator,
-  videoFilesDeleteWebTorrentValidator,
+  videoFilesDeleteWebVideoFileValidator,
+  videoFilesDeleteWebVideoValidator,
   videosGetValidator
 } from '../../../middlewares'
-import { updatePlaylistAfterFileChange } from '@server/lib/hls'
 
 const lTags = loggerTagsFactory('api', 'video')
 const filesRouter = express.Router()
@@ -40,17 +40,19 @@ filesRouter.delete('/:id/hls/:videoFileId',
   asyncMiddleware(removeHLSFileController)
 )
 
-filesRouter.delete('/:id/webtorrent',
+filesRouter.delete(
+  [ '/:id/webtorrent', '/:id/web-videos' ], // TODO: remove webtorrent in V7
   authenticate,
   ensureUserHasRight(UserRight.MANAGE_VIDEO_FILES),
-  asyncMiddleware(videoFilesDeleteWebTorrentValidator),
-  asyncMiddleware(removeAllWebTorrentFilesController)
+  asyncMiddleware(videoFilesDeleteWebVideoValidator),
+  asyncMiddleware(removeAllWebVideoFilesController)
 )
-filesRouter.delete('/:id/webtorrent/:videoFileId',
+filesRouter.delete(
+  [ '/:id/webtorrent/:videoFileId', '/:id/web-videos/:videoFileId' ], // TODO: remove webtorrent in V7
   authenticate,
   ensureUserHasRight(UserRight.MANAGE_VIDEO_FILES),
-  asyncMiddleware(videoFilesDeleteWebTorrentFileValidator),
-  asyncMiddleware(removeWebTorrentFileController)
+  asyncMiddleware(videoFilesDeleteWebVideoFileValidator),
+  asyncMiddleware(removeWebVideoFileController)
 )
 
 // ---------------------------------------------------------------------------
@@ -96,24 +98,24 @@ async function removeHLSFileController (req: express.Request, res: express.Respo
 
 // ---------------------------------------------------------------------------
 
-async function removeAllWebTorrentFilesController (req: express.Request, res: express.Response) {
+async function removeAllWebVideoFilesController (req: express.Request, res: express.Response) {
   const video = res.locals.videoAll
 
-  logger.info('Deleting WebTorrent files of %s.', video.url, lTags(video.uuid))
+  logger.info('Deleting Web Video files of %s.', video.url, lTags(video.uuid))
 
-  await removeAllWebTorrentFiles(video)
+  await removeAllWebVideoFiles(video)
   await federateVideoIfNeeded(video, false, undefined)
 
   return res.sendStatus(HttpStatusCode.NO_CONTENT_204)
 }
 
-async function removeWebTorrentFileController (req: express.Request, res: express.Response) {
+async function removeWebVideoFileController (req: express.Request, res: express.Response) {
   const video = res.locals.videoAll
 
   const videoFileId = +req.params.videoFileId
-  logger.info('Deleting WebTorrent file %d of %s.', videoFileId, video.url, lTags(video.uuid))
+  logger.info('Deleting Web Video file %d of %s.', videoFileId, video.url, lTags(video.uuid))
 
-  await removeWebTorrentFile(video, videoFileId)
+  await removeWebVideoFile(video, videoFileId)
   await federateVideoIfNeeded(video, false, undefined)
 
   return res.sendStatus(HttpStatusCode.NO_CONTENT_204)
diff --git a/server/controllers/api/videos/import.ts b/server/controllers/api/videos/import.ts
index 6a50aaf4e..defe9efd4 100644
--- a/server/controllers/api/videos/import.ts
+++ b/server/controllers/api/videos/import.ts
@@ -14,7 +14,7 @@ import { getSecureTorrentName } from '../../../helpers/utils'
 import { CONFIG } from '../../../initializers/config'
 import { MIMETYPES } from '../../../initializers/constants'
 import { JobQueue } from '../../../lib/job-queue/job-queue'
-import { updateVideoMiniatureFromExisting } from '../../../lib/thumbnail'
+import { updateLocalVideoMiniatureFromExisting } from '../../../lib/thumbnail'
 import {
   asyncMiddleware,
   asyncRetryTransactionMiddleware,
@@ -120,6 +120,7 @@ async function handleTorrentImport (req: express.Request, res: express.Response,
     videoChannel: res.locals.videoChannel,
     tags: body.tags || undefined,
     user,
+    videoPasswords: body.videoPasswords,
     videoImportAttributes: {
       magnetUri,
       torrentName,
@@ -192,7 +193,7 @@ async function processThumbnail (req: express.Request, video: MVideoThumbnail) {
   if (thumbnailField) {
     const thumbnailPhysicalFile = thumbnailField[0]
 
-    return updateVideoMiniatureFromExisting({
+    return updateLocalVideoMiniatureFromExisting({
       inputPath: thumbnailPhysicalFile.path,
       video,
       type: ThumbnailType.MINIATURE,
@@ -208,7 +209,7 @@ async function processPreview (req: express.Request, video: MVideoThumbnail): Pr
   if (previewField) {
     const previewPhysicalFile = previewField[0]
 
-    return updateVideoMiniatureFromExisting({
+    return updateLocalVideoMiniatureFromExisting({
       inputPath: previewPhysicalFile.path,
       video,
       type: ThumbnailType.PREVIEW,
diff --git a/server/controllers/api/videos/index.ts b/server/controllers/api/videos/index.ts
index a34325e79..520d8cbbb 100644
--- a/server/controllers/api/videos/index.ts
+++ b/server/controllers/api/videos/index.ts
@@ -3,7 +3,6 @@ import { pickCommonVideoQuery } from '@server/helpers/query'
 import { doJSONRequest } from '@server/helpers/requests'
 import { openapiOperationDoc } from '@server/middlewares/doc'
 import { getServerActor } from '@server/models/application/application'
-import { guessAdditionalAttributesFromQuery } from '@server/models/video/formatter/video-format-utils'
 import { MVideoAccountLight } from '@server/types/models'
 import { HttpStatusCode } from '../../../../shared/models'
 import { auditLoggerFactory, getAuditIdFromRes, VideoAuditView } from '../../../helpers/audit-logger'
@@ -31,6 +30,7 @@ import {
   videosRemoveValidator,
   videosSortValidator
 } from '../../../middlewares'
+import { guessAdditionalAttributesFromQuery } from '../../../models/video/formatter'
 import { VideoModel } from '../../../models/video/video'
 import { blacklistRouter } from './blacklist'
 import { videoCaptionsRouter } from './captions'
@@ -41,12 +41,14 @@ import { liveRouter } from './live'
 import { ownershipVideoRouter } from './ownership'
 import { rateVideoRouter } from './rate'
 import { statsRouter } from './stats'
+import { storyboardRouter } from './storyboard'
 import { studioRouter } from './studio'
 import { tokenRouter } from './token'
 import { transcodingRouter } from './transcoding'
 import { updateRouter } from './update'
 import { uploadRouter } from './upload'
 import { viewRouter } from './view'
+import { videoPasswordRouter } from './passwords'
 
 const auditLogger = auditLoggerFactory('videos')
 const videosRouter = express.Router()
@@ -68,6 +70,8 @@ videosRouter.use('/', updateRouter)
 videosRouter.use('/', filesRouter)
 videosRouter.use('/', transcodingRouter)
 videosRouter.use('/', tokenRouter)
+videosRouter.use('/', videoPasswordRouter)
+videosRouter.use('/', storyboardRouter)
 
 videosRouter.get('/categories',
   openapiOperationDoc({ operationId: 'getCategories' }),
diff --git a/server/controllers/api/videos/live.ts b/server/controllers/api/videos/live.ts
index de047d4ec..e19e8c652 100644
--- a/server/controllers/api/videos/live.ts
+++ b/server/controllers/api/videos/live.ts
@@ -18,13 +18,14 @@ import { VideoLiveModel } from '@server/models/video/video-live'
 import { VideoLiveSessionModel } from '@server/models/video/video-live-session'
 import { MVideoDetails, MVideoFullLight, MVideoLive } from '@server/types/models'
 import { buildUUID, uuidToShort } from '@shared/extra-utils'
-import { HttpStatusCode, LiveVideoCreate, LiveVideoLatencyMode, LiveVideoUpdate, UserRight, VideoState } from '@shared/models'
+import { HttpStatusCode, LiveVideoCreate, LiveVideoLatencyMode, LiveVideoUpdate, UserRight, VideoPrivacy, VideoState } from '@shared/models'
 import { logger } from '../../../helpers/logger'
 import { sequelizeTypescript } from '../../../initializers/database'
-import { updateVideoMiniatureFromExisting } from '../../../lib/thumbnail'
+import { updateLocalVideoMiniatureFromExisting } from '../../../lib/thumbnail'
 import { asyncMiddleware, asyncRetryTransactionMiddleware, authenticate, optionalAuthenticate } from '../../../middlewares'
 import { VideoModel } from '../../../models/video/video'
 import { VideoLiveReplaySettingModel } from '@server/models/video/video-live-replay-setting'
+import { VideoPasswordModel } from '@server/models/video/video-password'
 
 const liveRouter = express.Router()
 
@@ -165,7 +166,7 @@ async function addLiveVideo (req: express.Request, res: express.Response) {
     video,
     files: req.files,
     fallback: type => {
-      return updateVideoMiniatureFromExisting({
+      return updateLocalVideoMiniatureFromExisting({
         inputPath: ASSETS_PATH.DEFAULT_LIVE_BACKGROUND,
         video,
         type,
@@ -202,6 +203,10 @@ async function addLiveVideo (req: express.Request, res: express.Response) {
 
     await federateVideoIfNeeded(videoCreated, true, t)
 
+    if (videoInfo.privacy === VideoPrivacy.PASSWORD_PROTECTED) {
+      await VideoPasswordModel.addPasswords(videoInfo.videoPasswords, video.id, t)
+    }
+
     logger.info('Video live %s with uuid %s created.', videoInfo.name, videoCreated.uuid)
 
     return { videoCreated }
diff --git a/server/controllers/api/videos/passwords.ts b/server/controllers/api/videos/passwords.ts
new file mode 100644
index 000000000..d11cf5bcc
--- /dev/null
+++ b/server/controllers/api/videos/passwords.ts
@@ -0,0 +1,105 @@
+import express from 'express'
+
+import { HttpStatusCode } from '../../../../shared/models/http/http-error-codes'
+import { getFormattedObjects } from '../../../helpers/utils'
+import {
+  asyncMiddleware,
+  asyncRetryTransactionMiddleware,
+  authenticate,
+  setDefaultPagination,
+  setDefaultSort
+} from '../../../middlewares'
+import {
+  listVideoPasswordValidator,
+  paginationValidator,
+  removeVideoPasswordValidator,
+  updateVideoPasswordListValidator,
+  videoPasswordsSortValidator
+} from '../../../middlewares/validators'
+import { VideoPasswordModel } from '@server/models/video/video-password'
+import { logger, loggerTagsFactory } from '@server/helpers/logger'
+import { Transaction } from 'sequelize'
+import { getVideoWithAttributes } from '@server/helpers/video'
+
+const lTags = loggerTagsFactory('api', 'video')
+const videoPasswordRouter = express.Router()
+
+videoPasswordRouter.get('/:videoId/passwords',
+  authenticate,
+  paginationValidator,
+  videoPasswordsSortValidator,
+  setDefaultSort,
+  setDefaultPagination,
+  asyncMiddleware(listVideoPasswordValidator),
+  asyncMiddleware(listVideoPasswords)
+)
+
+videoPasswordRouter.put('/:videoId/passwords',
+  authenticate,
+  asyncMiddleware(updateVideoPasswordListValidator),
+  asyncMiddleware(updateVideoPasswordList)
+)
+
+videoPasswordRouter.delete('/:videoId/passwords/:passwordId',
+  authenticate,
+  asyncMiddleware(removeVideoPasswordValidator),
+  asyncRetryTransactionMiddleware(removeVideoPassword)
+)
+
+// ---------------------------------------------------------------------------
+
+export {
+  videoPasswordRouter
+}
+
+// ---------------------------------------------------------------------------
+
+async function listVideoPasswords (req: express.Request, res: express.Response) {
+  const options = {
+    videoId: res.locals.videoAll.id,
+    start: req.query.start,
+    count: req.query.count,
+    sort: req.query.sort
+  }
+
+  const resultList = await VideoPasswordModel.listPasswords(options)
+
+  return res.json(getFormattedObjects(resultList.data, resultList.total))
+}
+
+async function updateVideoPasswordList (req: express.Request, res: express.Response) {
+  const videoInstance = getVideoWithAttributes(res)
+  const videoId = videoInstance.id
+
+  const passwordArray = req.body.passwords as string[]
+
+  await VideoPasswordModel.sequelize.transaction(async (t: Transaction) => {
+    await VideoPasswordModel.deleteAllPasswords(videoId, t)
+    await VideoPasswordModel.addPasswords(passwordArray, videoId, t)
+  })
+
+  logger.info(
+    `Video passwords for video with name %s and uuid %s have been updated`,
+    videoInstance.name,
+    videoInstance.uuid,
+    lTags(videoInstance.uuid)
+  )
+
+  return res.sendStatus(HttpStatusCode.NO_CONTENT_204)
+}
+
+async function removeVideoPassword (req: express.Request, res: express.Response) {
+  const videoInstance = getVideoWithAttributes(res)
+  const password = res.locals.videoPassword
+
+  await VideoPasswordModel.deletePassword(password.id)
+  logger.info(
+    'Password with id %d of video named %s and uuid %s has been deleted.',
+    password.id,
+    videoInstance.name,
+    videoInstance.uuid,
+    lTags(videoInstance.uuid)
+  )
+
+  return res.sendStatus(HttpStatusCode.NO_CONTENT_204)
+}
diff --git a/server/controllers/api/videos/storyboard.ts b/server/controllers/api/videos/storyboard.ts
new file mode 100644
index 000000000..47a22011d
--- /dev/null
+++ b/server/controllers/api/videos/storyboard.ts
@@ -0,0 +1,29 @@
+import express from 'express'
+import { getVideoWithAttributes } from '@server/helpers/video'
+import { StoryboardModel } from '@server/models/video/storyboard'
+import { asyncMiddleware, videosGetValidator } from '../../../middlewares'
+
+const storyboardRouter = express.Router()
+
+storyboardRouter.get('/:id/storyboards',
+  asyncMiddleware(videosGetValidator),
+  asyncMiddleware(listStoryboards)
+)
+
+// ---------------------------------------------------------------------------
+
+export {
+  storyboardRouter
+}
+
+// ---------------------------------------------------------------------------
+
+async function listStoryboards (req: express.Request, res: express.Response) {
+  const video = getVideoWithAttributes(res)
+
+  const storyboards = await StoryboardModel.listStoryboardsOf(video)
+
+  return res.json({
+    storyboards: storyboards.map(s => s.toFormattedJSON())
+  })
+}
diff --git a/server/controllers/api/videos/token.ts b/server/controllers/api/videos/token.ts
index 22387c3e8..e961ffd9e 100644
--- a/server/controllers/api/videos/token.ts
+++ b/server/controllers/api/videos/token.ts
@@ -1,13 +1,14 @@
 import express from 'express'
 import { VideoTokensManager } from '@server/lib/video-tokens-manager'
-import { VideoToken } from '@shared/models'
-import { asyncMiddleware, authenticate, videosCustomGetValidator } from '../../../middlewares'
+import { VideoPrivacy, VideoToken } from '@shared/models'
+import { asyncMiddleware, optionalAuthenticate, videoFileTokenValidator, videosCustomGetValidator } from '../../../middlewares'
 
 const tokenRouter = express.Router()
 
 tokenRouter.post('/:id/token',
-  authenticate,
+  optionalAuthenticate,
   asyncMiddleware(videosCustomGetValidator('only-video')),
+  videoFileTokenValidator,
   generateToken
 )
 
@@ -22,12 +23,11 @@ export {
 function generateToken (req: express.Request, res: express.Response) {
   const video = res.locals.onlyVideo
 
-  const { token, expires } = VideoTokensManager.Instance.create({ videoUUID: video.uuid, user: res.locals.oauth.token.User })
+  const files = video.privacy === VideoPrivacy.PASSWORD_PROTECTED
+    ? VideoTokensManager.Instance.createForPasswordProtectedVideo({ videoUUID: video.uuid })
+    : VideoTokensManager.Instance.createForAuthUser({ videoUUID: video.uuid, user: res.locals.oauth.token.User })
 
   return res.json({
-    files: {
-      token,
-      expires
-    }
+    files
   } as VideoToken)
 }
diff --git a/server/controllers/api/videos/update.ts b/server/controllers/api/videos/update.ts
index ddab428d4..28ec2cf37 100644
--- a/server/controllers/api/videos/update.ts
+++ b/server/controllers/api/videos/update.ts
@@ -2,13 +2,12 @@ import express from 'express'
 import { Transaction } from 'sequelize/types'
 import { changeVideoChannelShare } from '@server/lib/activitypub/share'
 import { addVideoJobsAfterUpdate, buildVideoThumbnailsFromReq, setVideoTags } from '@server/lib/video'
-import { VideoPathManager } from '@server/lib/video-path-manager'
 import { setVideoPrivacy } from '@server/lib/video-privacy'
 import { openapiOperationDoc } from '@server/middlewares/doc'
 import { FilteredModelAttributes } from '@server/types'
 import { MVideoFullLight } from '@server/types/models'
 import { forceNumber } from '@shared/core-utils'
-import { HttpStatusCode, VideoUpdate } from '@shared/models'
+import { HttpStatusCode, VideoPrivacy, VideoUpdate } from '@shared/models'
 import { auditLoggerFactory, getAuditIdFromRes, VideoAuditView } from '../../../helpers/audit-logger'
 import { resetSequelizeInstance } from '../../../helpers/database-utils'
 import { createReqFiles } from '../../../helpers/express-utils'
@@ -20,6 +19,9 @@ import { autoBlacklistVideoIfNeeded } from '../../../lib/video-blacklist'
 import { asyncMiddleware, asyncRetryTransactionMiddleware, authenticate, videosUpdateValidator } from '../../../middlewares'
 import { ScheduleVideoUpdateModel } from '../../../models/video/schedule-video-update'
 import { VideoModel } from '../../../models/video/video'
+import { VideoPathManager } from '@server/lib/video-path-manager'
+import { VideoPasswordModel } from '@server/models/video/video-password'
+import { exists } from '@server/helpers/custom-validators/misc'
 
 const lTags = loggerTagsFactory('api', 'video')
 const auditLogger = auditLoggerFactory('videos')
@@ -176,6 +178,16 @@ async function updateVideoPrivacy (options: {
   const newPrivacy = forceNumber(videoInfoToUpdate.privacy)
   setVideoPrivacy(videoInstance, newPrivacy)
 
+  // Delete passwords if video is not anymore password protected
+  if (videoInstance.privacy === VideoPrivacy.PASSWORD_PROTECTED && newPrivacy !== VideoPrivacy.PASSWORD_PROTECTED) {
+    await VideoPasswordModel.deleteAllPasswords(videoInstance.id, transaction)
+  }
+
+  if (newPrivacy === VideoPrivacy.PASSWORD_PROTECTED && exists(videoInfoToUpdate.videoPasswords)) {
+    await VideoPasswordModel.deleteAllPasswords(videoInstance.id, transaction)
+    await VideoPasswordModel.addPasswords(videoInfoToUpdate.videoPasswords, videoInstance.id, transaction)
+  }
+
   // Unfederate the video if the new privacy is not compatible with federation
   if (hadPrivacyForFederation && !videoInstance.hasPrivacyForFederation()) {
     await VideoModel.sendDelete(videoInstance, { transaction })
diff --git a/server/controllers/api/videos/upload.ts b/server/controllers/api/videos/upload.ts
index 885ac8b81..27fef0b1a 100644
--- a/server/controllers/api/videos/upload.ts
+++ b/server/controllers/api/videos/upload.ts
@@ -14,14 +14,14 @@ import { openapiOperationDoc } from '@server/middlewares/doc'
 import { VideoSourceModel } from '@server/models/video/video-source'
 import { MUserId, MVideoFile, MVideoFullLight } from '@server/types/models'
 import { uuidToShort } from '@shared/extra-utils'
-import { HttpStatusCode, VideoCreate, VideoState } from '@shared/models'
+import { HttpStatusCode, VideoCreate, VideoPrivacy, VideoState } from '@shared/models'
 import { auditLoggerFactory, getAuditIdFromRes, VideoAuditView } from '../../../helpers/audit-logger'
 import { createReqFiles } from '../../../helpers/express-utils'
 import { logger, loggerTagsFactory } from '../../../helpers/logger'
 import { MIMETYPES } from '../../../initializers/constants'
 import { sequelizeTypescript } from '../../../initializers/database'
 import { Hooks } from '../../../lib/plugins/hooks'
-import { generateVideoMiniature } from '../../../lib/thumbnail'
+import { generateLocalVideoMiniature } from '../../../lib/thumbnail'
 import { autoBlacklistVideoIfNeeded } from '../../../lib/video-blacklist'
 import {
   asyncMiddleware,
@@ -33,6 +33,7 @@ import {
 } from '../../../middlewares'
 import { ScheduleVideoUpdateModel } from '../../../models/video/schedule-video-update'
 import { VideoModel } from '../../../models/video/video'
+import { VideoPasswordModel } from '@server/models/video/video-password'
 
 const lTags = loggerTagsFactory('api', 'video')
 const auditLogger = auditLoggerFactory('videos')
@@ -62,13 +63,13 @@ uploadRouter.post('/upload-resumable',
   authenticate,
   reqVideoFileAddResumable,
   asyncMiddleware(videosAddResumableInitValidator),
-  uploadx.upload
+  (req, res) => uploadx.upload(req, res) // Prevent next() call, explicitely tell to uploadx it's the end
 )
 
 uploadRouter.delete('/upload-resumable',
   authenticate,
   asyncMiddleware(deleteUploadResumableCache),
-  uploadx.upload
+  (req, res) => uploadx.upload(req, res) // Prevent next() call, explicitely tell to uploadx it's the end
 )
 
 uploadRouter.put('/upload-resumable',
@@ -110,7 +111,7 @@ async function addVideoLegacy (req: express.Request, res: express.Response) {
 async function addVideoResumable (req: express.Request, res: express.Response) {
   const videoPhysicalFile = res.locals.videoFileResumable
   const videoInfo = videoPhysicalFile.metadata
-  const files = { previewfile: videoInfo.previewfile }
+  const files = { previewfile: videoInfo.previewfile, thumbnailfile: videoInfo.thumbnailfile }
 
   const response = await addVideo({ req, res, videoPhysicalFile, videoInfo, files })
   await Redis.Instance.setUploadSession(req.query.upload_id, response)
@@ -152,7 +153,7 @@ async function addVideo (options: {
   const [ thumbnailModel, previewModel ] = await buildVideoThumbnailsFromReq({
     video,
     files,
-    fallback: type => generateVideoMiniature({ video, videoFile, type })
+    fallback: type => generateLocalVideoMiniature({ video, videoFile, type })
   })
 
   const { videoCreated } = await sequelizeTypescript.transaction(async t => {
@@ -195,6 +196,10 @@ async function addVideo (options: {
       transaction: t
     })
 
+    if (videoInfo.privacy === VideoPrivacy.PASSWORD_PROTECTED) {
+      await VideoPasswordModel.addPasswords(videoInfo.videoPasswords, video.id, t)
+    }
+
     auditLogger.create(getAuditIdFromRes(res), new VideoAuditView(videoCreated.toFormattedDetailsJSON()))
     logger.info('Video with name %s and uuid %s created.', videoInfo.name, videoCreated.uuid, lTags(videoCreated.uuid))
 
@@ -230,6 +235,15 @@ async function addVideoJobsAfterUpload (video: MVideoFullLight, videoFile: MVide
     },
 
     {
+      type: 'generate-video-storyboard' as 'generate-video-storyboard',
+      payload: {
+        videoUUID: video.uuid,
+        // No need to federate, we process these jobs sequentially
+        federate: false
+      }
+    },
+
+    {
       type: 'notify',
       payload: {
         action: 'new-video',
diff --git a/server/controllers/download.ts b/server/controllers/download.ts
index d675a2d6c..4b94e34bd 100644
--- a/server/controllers/download.ts
+++ b/server/controllers/download.ts
@@ -1,11 +1,12 @@
 import cors from 'cors'
 import express from 'express'
 import { logger } from '@server/helpers/logger'
-import { VideosTorrentCache } from '@server/lib/files-cache/videos-torrent-cache'
+import { VideoTorrentsSimpleFileCache } from '@server/lib/files-cache'
+import { generateHLSFilePresignedUrl, generateWebVideoPresignedUrl } from '@server/lib/object-storage'
 import { Hooks } from '@server/lib/plugins/hooks'
 import { VideoPathManager } from '@server/lib/video-path-manager'
-import { MStreamingPlaylist, MVideo, MVideoFile, MVideoFullLight } from '@server/types/models'
-import { addQueryParams, forceNumber } from '@shared/core-utils'
+import { MStreamingPlaylist, MStreamingPlaylistVideo, MVideo, MVideoFile, MVideoFullLight } from '@server/types/models'
+import { forceNumber } from '@shared/core-utils'
 import { HttpStatusCode, VideoStorage, VideoStreamingPlaylistType } from '@shared/models'
 import { STATIC_DOWNLOAD_PATHS } from '../initializers/constants'
 import { asyncMiddleware, optionalAuthenticate, videosDownloadValidator } from '../middlewares'
@@ -42,7 +43,7 @@ export {
 // ---------------------------------------------------------------------------
 
 async function downloadTorrent (req: express.Request, res: express.Response) {
-  const result = await VideosTorrentCache.Instance.getFilePath(req.params.filename)
+  const result = await VideoTorrentsSimpleFileCache.Instance.getFilePath(req.params.filename)
   if (!result) {
     return res.fail({
       status: HttpStatusCode.NOT_FOUND_404,
@@ -94,16 +95,16 @@ async function downloadVideoFile (req: express.Request, res: express.Response) {
 
   if (!checkAllowResult(res, allowParameters, allowedResult)) return
 
+  // Express uses basename on filename parameter
+  const videoName = video.name.replace(/[/\\]/g, '_')
+  const downloadFilename = `${videoName}-${videoFile.resolution}p${videoFile.extname}`
+
   if (videoFile.storage === VideoStorage.OBJECT_STORAGE) {
-    return redirectToObjectStorage({ req, res, video, file: videoFile })
+    return redirectToObjectStorage({ req, res, video, file: videoFile, downloadFilename })
   }
 
   await VideoPathManager.Instance.makeAvailableVideoFile(videoFile.withVideoOrPlaylist(video), path => {
-    // Express uses basename on filename parameter
-    const videoName = video.name.replace(/[/\\]/g, '_')
-    const filename = `${videoName}-${videoFile.resolution}p${videoFile.extname}`
-
-    return res.download(path, filename)
+    return res.download(path, downloadFilename)
   })
 }
 
@@ -136,14 +137,14 @@ async function downloadHLSVideoFile (req: express.Request, res: express.Response
 
   if (!checkAllowResult(res, allowParameters, allowedResult)) return
 
+  const downloadFilename = `${video.name}-${videoFile.resolution}p-${streamingPlaylist.getStringType()}${videoFile.extname}`
+
   if (videoFile.storage === VideoStorage.OBJECT_STORAGE) {
-    return redirectToObjectStorage({ req, res, video, file: videoFile })
+    return redirectToObjectStorage({ req, res, video, streamingPlaylist, file: videoFile, downloadFilename })
   }
 
   await VideoPathManager.Instance.makeAvailableVideoFile(videoFile.withVideoOrPlaylist(streamingPlaylist), path => {
-    const filename = `${video.name}-${videoFile.resolution}p-${streamingPlaylist.getStringType()}${videoFile.extname}`
-
-    return res.download(path, filename)
+    return res.download(path, downloadFilename)
   })
 }
 
@@ -192,19 +193,21 @@ function checkAllowResult (res: express.Response, allowParameters: any, result?:
   return true
 }
 
-function redirectToObjectStorage (options: {
+async function redirectToObjectStorage (options: {
   req: express.Request
   res: express.Response
   video: MVideo
   file: MVideoFile
+  streamingPlaylist?: MStreamingPlaylistVideo
+  downloadFilename: string
 }) {
-  const { req, res, video, file } = options
+  const { res, video, streamingPlaylist, file, downloadFilename } = options
 
-  const baseUrl = file.getObjectStorageUrl(video)
+  const url = streamingPlaylist
+    ? await generateHLSFilePresignedUrl({ streamingPlaylist, file, downloadFilename })
+    : await generateWebVideoPresignedUrl({ file, downloadFilename })
 
-  const url = video.hasPrivateStaticPath() && req.query.videoFileToken
-    ? addQueryParams(baseUrl, { videoFileToken: req.query.videoFileToken })
-    : baseUrl
+  logger.debug('Generating pre-signed URL %s for video %s', url, video.uuid)
 
   return res.redirect(url)
 }
diff --git a/server/controllers/feeds/shared/video-feed-utils.ts b/server/controllers/feeds/shared/video-feed-utils.ts
index 3175cea59..b154e04fa 100644
--- a/server/controllers/feeds/shared/video-feed-utils.ts
+++ b/server/controllers/feeds/shared/video-feed-utils.ts
@@ -2,7 +2,7 @@ import { mdToOneLinePlainText, toSafeHtml } from '@server/helpers/markdown'
 import { CONFIG } from '@server/initializers/config'
 import { WEBSERVER } from '@server/initializers/constants'
 import { getServerActor } from '@server/models/application/application'
-import { getCategoryLabel } from '@server/models/video/formatter/video-format-utils'
+import { getCategoryLabel } from '@server/models/video/formatter'
 import { DisplayOnlyForFollowerOptions } from '@server/models/video/sql/video'
 import { VideoModel } from '@server/models/video/video'
 import { MThumbnail, MUserDefault } from '@server/types/models'
diff --git a/server/controllers/lazy-static.ts b/server/controllers/lazy-static.ts
index b082e41f6..dad30365c 100644
--- a/server/controllers/lazy-static.ts
+++ b/server/controllers/lazy-static.ts
@@ -1,14 +1,28 @@
 import cors from 'cors'
 import express from 'express'
-import { VideosTorrentCache } from '@server/lib/files-cache/videos-torrent-cache'
-import { MActorImage } from '@server/types/models'
+import { CONFIG } from '@server/initializers/config'
 import { HttpStatusCode } from '../../shared/models/http/http-error-codes'
-import { logger } from '../helpers/logger'
-import { ACTOR_IMAGES_SIZE, LAZY_STATIC_PATHS, STATIC_MAX_AGE } from '../initializers/constants'
-import { VideosCaptionCache, VideosPreviewCache } from '../lib/files-cache'
-import { actorImagePathUnsafeCache, downloadActorImageFromWorker } from '../lib/local-actor'
+import { FILES_CACHE, LAZY_STATIC_PATHS, STATIC_MAX_AGE } from '../initializers/constants'
+import {
+  AvatarPermanentFileCache,
+  VideoCaptionsSimpleFileCache,
+  VideoMiniaturePermanentFileCache,
+  VideoPreviewsSimpleFileCache,
+  VideoStoryboardsSimpleFileCache,
+  VideoTorrentsSimpleFileCache
+} from '../lib/files-cache'
 import { asyncMiddleware, handleStaticError } from '../middlewares'
-import { ActorImageModel } from '../models/actor/actor-image'
+
+// ---------------------------------------------------------------------------
+// Cache initializations
+// ---------------------------------------------------------------------------
+
+VideoPreviewsSimpleFileCache.Instance.init(CONFIG.CACHE.PREVIEWS.SIZE, FILES_CACHE.PREVIEWS.MAX_AGE)
+VideoCaptionsSimpleFileCache.Instance.init(CONFIG.CACHE.VIDEO_CAPTIONS.SIZE, FILES_CACHE.VIDEO_CAPTIONS.MAX_AGE)
+VideoTorrentsSimpleFileCache.Instance.init(CONFIG.CACHE.TORRENTS.SIZE, FILES_CACHE.TORRENTS.MAX_AGE)
+VideoStoryboardsSimpleFileCache.Instance.init(CONFIG.CACHE.STORYBOARDS.SIZE, FILES_CACHE.STORYBOARDS.MAX_AGE)
+
+// ---------------------------------------------------------------------------
 
 const lazyStaticRouter = express.Router()
 
@@ -27,12 +41,24 @@ lazyStaticRouter.use(
 )
 
 lazyStaticRouter.use(
+  LAZY_STATIC_PATHS.THUMBNAILS + ':filename',
+  asyncMiddleware(getThumbnail),
+  handleStaticError
+)
+
+lazyStaticRouter.use(
   LAZY_STATIC_PATHS.PREVIEWS + ':filename',
   asyncMiddleware(getPreview),
   handleStaticError
 )
 
 lazyStaticRouter.use(
+  LAZY_STATIC_PATHS.STORYBOARDS + ':filename',
+  asyncMiddleware(getStoryboard),
+  handleStaticError
+)
+
+lazyStaticRouter.use(
   LAZY_STATIC_PATHS.VIDEO_CAPTIONS + ':filename',
   asyncMiddleware(getVideoCaption),
   handleStaticError
@@ -53,88 +79,48 @@ export {
 }
 
 // ---------------------------------------------------------------------------
+const avatarPermanentFileCache = new AvatarPermanentFileCache()
 
-async function getActorImage (req: express.Request, res: express.Response, next: express.NextFunction) {
+function getActorImage (req: express.Request, res: express.Response, next: express.NextFunction) {
   const filename = req.params.filename
 
-  if (actorImagePathUnsafeCache.has(filename)) {
-    return res.sendFile(actorImagePathUnsafeCache.get(filename), { maxAge: STATIC_MAX_AGE.SERVER })
-  }
-
-  const image = await ActorImageModel.loadByName(filename)
-  if (!image) return res.status(HttpStatusCode.NOT_FOUND_404).end()
-
-  if (image.onDisk === false) {
-    if (!image.fileUrl) return res.status(HttpStatusCode.NOT_FOUND_404).end()
-
-    logger.info('Lazy serve remote actor image %s.', image.fileUrl)
-
-    try {
-      await downloadActorImageFromWorker({
-        filename: image.filename,
-        fileUrl: image.fileUrl,
-        size: getActorImageSize(image),
-        type: image.type
-      })
-    } catch (err) {
-      logger.warn('Cannot process remote actor image %s.', image.fileUrl, { err })
-      return res.status(HttpStatusCode.NOT_FOUND_404).end()
-    }
-
-    image.onDisk = true
-    image.save()
-      .catch(err => logger.error('Cannot save new actor image disk state.', { err }))
-  }
-
-  const path = image.getPath()
-
-  actorImagePathUnsafeCache.set(filename, path)
-
-  return res.sendFile(path, { maxAge: STATIC_MAX_AGE.LAZY_SERVER }, (err: any) => {
-    if (!err) return
-
-    // 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 actor image %s.', filename, { err })
+  return avatarPermanentFileCache.lazyServe({ filename, res, next })
+}
 
-      actorImagePathUnsafeCache.delete(filename)
+// ---------------------------------------------------------------------------
+const videoMiniaturePermanentFileCache = new VideoMiniaturePermanentFileCache()
 
-      image.onDisk = false
-      image.save()
-       .catch(err => logger.error('Cannot save new actor image disk state.', { err }))
-    }
+function getThumbnail (req: express.Request, res: express.Response, next: express.NextFunction) {
+  const filename = req.params.filename
 
-    return next(err)
-  })
+  return videoMiniaturePermanentFileCache.lazyServe({ filename, res, next })
 }
 
-function getActorImageSize (image: MActorImage): { width: number, height: number } {
-  if (image.width && image.height) {
-    return {
-      height: image.height,
-      width: image.width
-    }
-  }
+// ---------------------------------------------------------------------------
+
+async function getPreview (req: express.Request, res: express.Response) {
+  const result = await VideoPreviewsSimpleFileCache.Instance.getFilePath(req.params.filename)
+  if (!result) return res.status(HttpStatusCode.NOT_FOUND_404).end()
 
-  return ACTOR_IMAGES_SIZE[image.type][0]
+  return res.sendFile(result.path, { maxAge: STATIC_MAX_AGE.LAZY_SERVER })
 }
 
-async function getPreview (req: express.Request, res: express.Response) {
-  const result = await VideosPreviewCache.Instance.getFilePath(req.params.filename)
+async function getStoryboard (req: express.Request, res: express.Response) {
+  const result = await VideoStoryboardsSimpleFileCache.Instance.getFilePath(req.params.filename)
   if (!result) return res.status(HttpStatusCode.NOT_FOUND_404).end()
 
   return res.sendFile(result.path, { maxAge: STATIC_MAX_AGE.LAZY_SERVER })
 }
 
 async function getVideoCaption (req: express.Request, res: express.Response) {
-  const result = await VideosCaptionCache.Instance.getFilePath(req.params.filename)
+  const result = await VideoCaptionsSimpleFileCache.Instance.getFilePath(req.params.filename)
   if (!result) return res.status(HttpStatusCode.NOT_FOUND_404).end()
 
   return res.sendFile(result.path, { maxAge: STATIC_MAX_AGE.LAZY_SERVER })
 }
 
 async function getTorrent (req: express.Request, res: express.Response) {
-  const result = await VideosTorrentCache.Instance.getFilePath(req.params.filename)
+  const result = await VideoTorrentsSimpleFileCache.Instance.getFilePath(req.params.filename)
   if (!result) return res.status(HttpStatusCode.NOT_FOUND_404).end()
 
   // Torrents still use the old naming convention (video uuid + .torrent)
diff --git a/server/controllers/misc.ts b/server/controllers/misc.ts
index 4c8af2adc..163352ac5 100644
--- a/server/controllers/misc.ts
+++ b/server/controllers/misc.ts
@@ -120,8 +120,8 @@ async function generateNodeinfo (req: express.Request, res: express.Response) {
           hls: {
             enabled: CONFIG.TRANSCODING.HLS.ENABLED
           },
-          webtorrent: {
-            enabled: CONFIG.TRANSCODING.WEBTORRENT.ENABLED
+          web_videos: {
+            enabled: CONFIG.TRANSCODING.WEB_VIDEOS.ENABLED
           },
           enabledResolutions: ServerConfigManager.Instance.getEnabledResolutions('vod')
         },
diff --git a/server/controllers/object-storage-proxy.ts b/server/controllers/object-storage-proxy.ts
index 8e2cc4af9..d0c59bf93 100644
--- a/server/controllers/object-storage-proxy.ts
+++ b/server/controllers/object-storage-proxy.ts
@@ -1,11 +1,11 @@
 import cors from 'cors'
 import express from 'express'
 import { OBJECT_STORAGE_PROXY_PATHS } from '@server/initializers/constants'
-import { proxifyHLS, proxifyWebTorrentFile } from '@server/lib/object-storage'
+import { proxifyHLS, proxifyWebVideoFile } from '@server/lib/object-storage'
 import {
   asyncMiddleware,
   ensureCanAccessPrivateVideoHLSFiles,
-  ensureCanAccessVideoPrivateWebTorrentFiles,
+  ensureCanAccessVideoPrivateWebVideoFiles,
   ensurePrivateObjectStorageProxyIsEnabled,
   optionalAuthenticate
 } from '@server/middlewares'
@@ -15,11 +15,12 @@ const objectStorageProxyRouter = express.Router()
 
 objectStorageProxyRouter.use(cors())
 
-objectStorageProxyRouter.get(OBJECT_STORAGE_PROXY_PATHS.PRIVATE_WEBSEED + ':filename',
+objectStorageProxyRouter.get(
+  [ OBJECT_STORAGE_PROXY_PATHS.PRIVATE_WEB_VIDEOS + ':filename', OBJECT_STORAGE_PROXY_PATHS.LEGACY_PRIVATE_WEB_VIDEOS + ':filename' ],
   ensurePrivateObjectStorageProxyIsEnabled,
   optionalAuthenticate,
-  asyncMiddleware(ensureCanAccessVideoPrivateWebTorrentFiles),
-  asyncMiddleware(proxifyWebTorrentController)
+  asyncMiddleware(ensureCanAccessVideoPrivateWebVideoFiles),
+  asyncMiddleware(proxifyWebVideoController)
 )
 
 objectStorageProxyRouter.get(OBJECT_STORAGE_PROXY_PATHS.STREAMING_PLAYLISTS.PRIVATE_HLS + ':videoUUID/:filename',
@@ -35,10 +36,10 @@ export {
   objectStorageProxyRouter
 }
 
-function proxifyWebTorrentController (req: express.Request, res: express.Response) {
+function proxifyWebVideoController (req: express.Request, res: express.Response) {
   const filename = req.params.filename
 
-  return proxifyWebTorrentFile({ req, res, filename })
+  return proxifyWebVideoFile({ req, res, filename })
 }
 
 function proxifyHLSController (req: express.Request, res: express.Response) {
diff --git a/server/controllers/static.ts b/server/controllers/static.ts
index 9baff94c0..97caa8292 100644
--- a/server/controllers/static.ts
+++ b/server/controllers/static.ts
@@ -6,7 +6,7 @@ import { injectQueryToPlaylistUrls } from '@server/lib/hls'
 import {
   asyncMiddleware,
   ensureCanAccessPrivateVideoHLSFiles,
-  ensureCanAccessVideoPrivateWebTorrentFiles,
+  ensureCanAccessVideoPrivateWebVideoFiles,
   handleStaticError,
   optionalAuthenticate
 } from '@server/middlewares'
@@ -21,21 +21,21 @@ const staticRouter = express.Router()
 staticRouter.use(cors())
 
 // ---------------------------------------------------------------------------
-// WebTorrent/Classic videos
+// Web videos/Classic videos
 // ---------------------------------------------------------------------------
 
-const privateWebTorrentStaticMiddlewares = CONFIG.STATIC_FILES.PRIVATE_FILES_REQUIRE_AUTH === true
-  ? [ optionalAuthenticate, asyncMiddleware(ensureCanAccessVideoPrivateWebTorrentFiles) ]
+const privateWebVideoStaticMiddlewares = CONFIG.STATIC_FILES.PRIVATE_FILES_REQUIRE_AUTH === true
+  ? [ optionalAuthenticate, asyncMiddleware(ensureCanAccessVideoPrivateWebVideoFiles) ]
   : []
 
 staticRouter.use(
-  STATIC_PATHS.PRIVATE_WEBSEED,
-  ...privateWebTorrentStaticMiddlewares,
+  [ STATIC_PATHS.PRIVATE_WEB_VIDEOS, STATIC_PATHS.LEGACY_PRIVATE_WEB_VIDEOS ],
+  ...privateWebVideoStaticMiddlewares,
   express.static(DIRECTORIES.VIDEOS.PRIVATE, { fallthrough: false }),
   handleStaticError
 )
 staticRouter.use(
-  STATIC_PATHS.WEBSEED,
+  [ STATIC_PATHS.WEB_VIDEOS, STATIC_PATHS.LEGACY_WEB_VIDEOS ],
   express.static(DIRECTORIES.VIDEOS.PUBLIC, { fallthrough: false }),
   handleStaticError
 )
@@ -72,7 +72,7 @@ staticRouter.use(
   handleStaticError
 )
 
-// Thumbnails path for express
+// FIXME: deprecated in v6, to remove
 const thumbnailsPhysicalPath = CONFIG.STORAGE.THUMBNAILS_DIR
 staticRouter.use(
   STATIC_PATHS.THUMBNAILS,
diff --git a/server/helpers/custom-validators/activitypub/misc.ts b/server/helpers/custom-validators/activitypub/misc.ts
index 279ad83dc..7df47cf15 100644
--- a/server/helpers/custom-validators/activitypub/misc.ts
+++ b/server/helpers/custom-validators/activitypub/misc.ts
@@ -51,7 +51,8 @@ function setValidAttributedTo (obj: any) {
   }
 
   obj.attributedTo = obj.attributedTo.filter(a => {
-    return (a.type === 'Group' || a.type === 'Person') && isActivityPubUrlValid(a.id)
+    return isActivityPubUrlValid(a) ||
+      ((a.type === 'Group' || a.type === 'Person') && isActivityPubUrlValid(a.id))
   })
 
   return true
diff --git a/server/helpers/custom-validators/activitypub/videos.ts b/server/helpers/custom-validators/activitypub/videos.ts
index 97b3577af..573a29754 100644
--- a/server/helpers/custom-validators/activitypub/videos.ts
+++ b/server/helpers/custom-validators/activitypub/videos.ts
@@ -1,6 +1,6 @@
 import validator from 'validator'
 import { logger } from '@server/helpers/logger'
-import { ActivityTrackerUrlObject, ActivityVideoFileMetadataUrlObject } from '@shared/models'
+import { ActivityPubStoryboard, ActivityTrackerUrlObject, ActivityVideoFileMetadataUrlObject, VideoObject } from '@shared/models'
 import { LiveVideoLatencyMode, VideoState } from '../../../../shared/models/videos'
 import { ACTIVITY_PUB, CONSTRAINTS_FIELDS } from '../../../initializers/constants'
 import { peertubeTruncate } from '../../core-utils'
@@ -48,6 +48,10 @@ function sanitizeAndCheckVideoTorrentObject (video: any) {
     logger.debug('Video has invalid icons', { video })
     return false
   }
+  if (!setValidStoryboard(video)) {
+    logger.debug('Video has invalid preview (storyboard)', { video })
+    return false
+  }
 
   // Default attributes
   if (!isVideoStateValid(video.state)) video.state = VideoState.PUBLISHED
@@ -201,3 +205,36 @@ function setRemoteVideoContent (video: any) {
 
   return true
 }
+
+function setValidStoryboard (video: VideoObject) {
+  if (!video.preview) return true
+  if (!Array.isArray(video.preview)) return false
+
+  video.preview = video.preview.filter(p => isStorybordValid(p))
+
+  return true
+}
+
+function isStorybordValid (preview: ActivityPubStoryboard) {
+  if (!preview) return false
+
+  if (
+    preview.type !== 'Image' ||
+    !isArray(preview.rel) ||
+    !preview.rel.includes('storyboard')
+  ) {
+    return false
+  }
+
+  preview.url = preview.url.filter(u => {
+    return u.mediaType === 'image/jpeg' &&
+      isActivityPubUrlValid(u.href) &&
+      validator.isInt(u.width + '', { min: 0 }) &&
+      validator.isInt(u.height + '', { min: 0 }) &&
+      validator.isInt(u.tileWidth + '', { min: 0 }) &&
+      validator.isInt(u.tileHeight + '', { min: 0 }) &&
+      isActivityPubVideoDurationValid(u.tileDuration)
+  })
+
+  return preview.url.length !== 0
+}
diff --git a/server/helpers/custom-validators/metrics.ts b/server/helpers/custom-validators/metrics.ts
index 533f8988d..44a863630 100644
--- a/server/helpers/custom-validators/metrics.ts
+++ b/server/helpers/custom-validators/metrics.ts
@@ -1,5 +1,6 @@
 function isValidPlayerMode (value: any) {
-  return value === 'webtorrent' || value === 'p2p-media-loader'
+  // TODO: remove webtorrent in v7
+  return value === 'webtorrent' || value === 'web-video' || value === 'p2p-media-loader'
 }
 
 // ---------------------------------------------------------------------------
diff --git a/server/helpers/custom-validators/video-transcoding.ts b/server/helpers/custom-validators/video-transcoding.ts
index cf792f996..220530de4 100644
--- a/server/helpers/custom-validators/video-transcoding.ts
+++ b/server/helpers/custom-validators/video-transcoding.ts
@@ -2,7 +2,7 @@ import { exists } from './misc'
 
 function isValidCreateTranscodingType (value: any) {
   return exists(value) &&
-    (value === 'hls' || value === 'webtorrent')
+    (value === 'hls' || value === 'webtorrent' || value === 'web-video') // TODO: remove webtorrent in v7
 }
 
 // ---------------------------------------------------------------------------
diff --git a/server/helpers/custom-validators/videos.ts b/server/helpers/custom-validators/videos.ts
index 5f75ec27c..91109217c 100644
--- a/server/helpers/custom-validators/videos.ts
+++ b/server/helpers/custom-validators/videos.ts
@@ -1,7 +1,7 @@
-import { UploadFilesForCheck } from 'express'
+import { Response, Request, UploadFilesForCheck } from 'express'
 import { decode as magnetUriDecode } from 'magnet-uri'
 import validator from 'validator'
-import { VideoFilter, VideoInclude, VideoPrivacy, VideoRateType } from '@shared/models'
+import { HttpStatusCode, VideoFilter, VideoInclude, VideoPrivacy, VideoRateType } from '@shared/models'
 import {
   CONSTRAINTS_FIELDS,
   MIMETYPES,
@@ -13,6 +13,7 @@ import {
   VIDEO_STATES
 } from '../../initializers/constants'
 import { exists, isArray, isDateValid, isFileValid } from './misc'
+import { getVideoWithAttributes } from '@server/helpers/video'
 
 const VIDEOS_CONSTRAINTS_FIELDS = CONSTRAINTS_FIELDS.VIDEOS
 
@@ -110,6 +111,10 @@ function isVideoPrivacyValid (value: number) {
   return VIDEO_PRIVACIES[value] !== undefined
 }
 
+function isVideoReplayPrivacyValid (value: number) {
+  return VIDEO_PRIVACIES[value] !== undefined && value !== VideoPrivacy.PASSWORD_PROTECTED
+}
+
 function isScheduleVideoUpdatePrivacyValid (value: number) {
   return value === VideoPrivacy.UNLISTED || value === VideoPrivacy.PUBLIC || value === VideoPrivacy.INTERNAL
 }
@@ -141,6 +146,49 @@ function isVideoMagnetUriValid (value: string) {
   return parsed && isVideoFileInfoHashValid(parsed.infoHash)
 }
 
+function isPasswordValid (password: string) {
+  return password.length >= CONSTRAINTS_FIELDS.VIDEO_PASSWORD.LENGTH.min &&
+    password.length < CONSTRAINTS_FIELDS.VIDEO_PASSWORD.LENGTH.max
+}
+
+function isValidPasswordProtectedPrivacy (req: Request, res: Response) {
+  const fail = (message: string) => {
+    res.fail({
+      status: HttpStatusCode.BAD_REQUEST_400,
+      message
+    })
+    return false
+  }
+
+  let privacy: VideoPrivacy
+  const video = getVideoWithAttributes(res)
+
+  if (exists(req.body?.privacy)) privacy = req.body.privacy
+  else if (exists(video?.privacy)) privacy = video.privacy
+
+  if (privacy !== VideoPrivacy.PASSWORD_PROTECTED) return true
+
+  if (!exists(req.body.videoPasswords) && !exists(req.body.passwords)) return fail('Video passwords are missing.')
+
+  const passwords = req.body.videoPasswords || req.body.passwords
+
+  if (passwords.length === 0) return fail('At least one video password is required.')
+
+  if (new Set(passwords).size !== passwords.length) return fail('Duplicate video passwords are not allowed.')
+
+  for (const password of passwords) {
+    if (typeof password !== 'string') {
+      return fail('Video password should be a string.')
+    }
+
+    if (!isPasswordValid(password)) {
+      return fail('Invalid video password. Password length should be at least 2 characters and no more than 100 characters.')
+    }
+  }
+
+  return true
+}
+
 // ---------------------------------------------------------------------------
 
 export {
@@ -164,9 +212,12 @@ export {
   isVideoDurationValid,
   isVideoTagValid,
   isVideoPrivacyValid,
+  isVideoReplayPrivacyValid,
   isVideoFileResolutionValid,
   isVideoFileSizeValid,
   isVideoImageValid,
   isVideoSupportValid,
-  isVideoFilterValid
+  isVideoFilterValid,
+  isPasswordValid,
+  isValidPasswordProtectedPrivacy
 }
diff --git a/server/helpers/express-utils.ts b/server/helpers/express-utils.ts
index 82dd4c178..783097e55 100644
--- a/server/helpers/express-utils.ts
+++ b/server/helpers/express-utils.ts
@@ -1,7 +1,6 @@
 import express, { RequestHandler } from 'express'
 import multer, { diskStorage } from 'multer'
 import { getLowercaseExtension } from '@shared/core-utils'
-import { HttpStatusCode } from '../../shared/models/http/http-error-codes'
 import { CONFIG } from '../initializers/config'
 import { REMOTE_SCHEME } from '../initializers/constants'
 import { isArray } from './custom-validators/misc'
@@ -59,12 +58,6 @@ function getHostWithPort (host: string) {
   return host
 }
 
-function badRequest (_req: express.Request, res: express.Response) {
-  return res.type('json')
-            .status(HttpStatusCode.BAD_REQUEST_400)
-            .end()
-}
-
 function createReqFiles (
   fieldNames: string[],
   mimeTypes: { [id: string]: string | string[] },
@@ -126,7 +119,6 @@ export {
   getHostWithPort,
   createAnyReqFiles,
   isUserAbleToSearchRemoteURI,
-  badRequest,
   createReqFiles,
   cleanUpReqFiles,
   getCountVideos
diff --git a/server/helpers/image-utils.ts b/server/helpers/image-utils.ts
index f86f7216d..7b77e694a 100644
--- a/server/helpers/image-utils.ts
+++ b/server/helpers/image-utils.ts
@@ -51,7 +51,7 @@ async function generateImageFromVideoFile (options: {
   const pendingImagePath = join(folder, pendingImageName)
 
   try {
-    await generateThumbnailFromVideo({ fromPath, folder, imageName })
+    await generateThumbnailFromVideo({ fromPath, output: pendingImagePath })
 
     const destination = join(folder, imageName)
     await processImage({ path: pendingImagePath, destination, newSize: size })
diff --git a/server/helpers/promise-cache.ts b/server/helpers/promise-cache.ts
index 07e8a9962..303bab976 100644
--- a/server/helpers/promise-cache.ts
+++ b/server/helpers/promise-cache.ts
@@ -1,4 +1,4 @@
-export class PromiseCache <A, R> {
+export class CachePromiseFactory <A, R> {
   private readonly running = new Map<string, Promise<R>>()
 
   constructor (
@@ -8,14 +8,32 @@ export class PromiseCache <A, R> {
   }
 
   run (arg: A) {
+    return this.runWithContext(null, arg)
+  }
+
+  runWithContext (ctx: any, arg: A) {
     const key = this.keyBuilder(arg)
 
     if (this.running.has(key)) return this.running.get(key)
 
-    const p = this.fn(arg)
+    const p = this.fn.apply(ctx || this, [ arg ])
 
     this.running.set(key, p)
 
     return p.finally(() => this.running.delete(key))
   }
 }
+
+export function CachePromise (options: {
+  keyBuilder: (...args: any[]) => string
+}) {
+  return function (_target, _key, descriptor: PropertyDescriptor) {
+    const promiseCache = new CachePromiseFactory(descriptor.value, options.keyBuilder)
+
+    descriptor.value = function () {
+      if (arguments.length !== 1) throw new Error('Cache promise only support methods with 1 argument')
+
+      return promiseCache.runWithContext(this, arguments[0])
+    }
+  }
+}
diff --git a/server/helpers/query.ts b/server/helpers/query.ts
index 10efae41c..c0f78368f 100644
--- a/server/helpers/query.ts
+++ b/server/helpers/query.ts
@@ -23,7 +23,8 @@ function pickCommonVideoQuery (query: VideosCommonQueryAfterSanitize) {
     'include',
     'skipCount',
     'hasHLSFiles',
-    'hasWebtorrentFiles',
+    'hasWebtorrentFiles', // TODO: Remove in v7
+    'hasWebVideoFiles',
     'search',
     'excludeAlreadyWatched'
   ])
diff --git a/server/initializers/checker-after-init.ts b/server/initializers/checker-after-init.ts
index 68dea909d..5ef72058b 100644
--- a/server/initializers/checker-after-init.ts
+++ b/server/initializers/checker-after-init.ts
@@ -1,4 +1,5 @@
 import config from 'config'
+import { readFileSync, writeFileSync } from 'fs-extra'
 import { URL } from 'url'
 import { uniqify } from '@shared/core-utils'
 import { getFFmpegVersion } from '@shared/ffmpeg'
@@ -10,7 +11,7 @@ import { logger } from '../helpers/logger'
 import { ApplicationModel, getServerActor } from '../models/application/application'
 import { OAuthClientModel } from '../models/oauth/oauth-client'
 import { UserModel } from '../models/user/user'
-import { CONFIG, isEmailEnabled } from './config'
+import { CONFIG, getLocalConfigFilePath, isEmailEnabled, reloadConfig } from './config'
 import { WEBSERVER } from './constants'
 
 async function checkActivityPubUrls () {
@@ -37,10 +38,7 @@ function checkConfig () {
   const configFiles = config.util.getConfigSources().map(s => s.name).join(' -> ')
   logger.info('Using following configuration file hierarchy: %s.', configFiles)
 
-  // Moved configuration keys
-  if (config.has('services.csp-logger')) {
-    logger.warn('services.csp-logger configuration has been renamed to csp.report_uri. Please update your configuration file.')
-  }
+  checkRemovedConfigKeys()
 
   checkSecretsConfig()
   checkEmailConfig()
@@ -104,6 +102,34 @@ export {
 
 // ---------------------------------------------------------------------------
 
+function checkRemovedConfigKeys () {
+  // Moved configuration keys
+  if (config.has('services.csp-logger')) {
+    logger.warn('services.csp-logger configuration has been renamed to csp.report_uri. Please update your configuration file.')
+  }
+
+  if (config.has('transcoding.webtorrent.enabled')) {
+    const localConfigPath = getLocalConfigFilePath()
+
+    const content = readFileSync(localConfigPath, { encoding: 'utf-8' })
+    if (!content.includes('"webtorrent"')) {
+      throw new Error('Please rename transcoding.webtorrent.enabled key to transcoding.web_videos.enabled in your configuration file')
+    }
+
+    try {
+      logger.info(
+        'Replacing "transcoding.webtorrent.enabled" key to "transcoding.web_videos.enabled" in your local configuration ' + localConfigPath
+      )
+
+      writeFileSync(localConfigPath, content.replace('"webtorrent"', '"web_videos"'), { encoding: 'utf-8' })
+
+      reloadConfig()
+    } catch (err) {
+      logger.error('Cannot write new configuration to file ' + localConfigPath, { err })
+    }
+  }
+}
+
 function checkSecretsConfig () {
   if (!CONFIG.SECRETS.PEERTUBE) {
     throw new Error('secrets.peertube is missing in config. Generate one using `openssl rand -hex 32`')
@@ -191,15 +217,15 @@ function checkStorageConfig () {
     }
   }
 
-  if (CONFIG.STORAGE.VIDEOS_DIR === CONFIG.STORAGE.REDUNDANCY_DIR) {
+  if (CONFIG.STORAGE.WEB_VIDEOS_DIR === CONFIG.STORAGE.REDUNDANCY_DIR) {
     logger.warn('Redundancy directory should be different than the videos folder.')
   }
 }
 
 function checkTranscodingConfig () {
   if (CONFIG.TRANSCODING.ENABLED) {
-    if (CONFIG.TRANSCODING.WEBTORRENT.ENABLED === false && CONFIG.TRANSCODING.HLS.ENABLED === false) {
-      throw new Error('You need to enable at least WebTorrent transcoding or HLS transcoding.')
+    if (CONFIG.TRANSCODING.WEB_VIDEOS.ENABLED === false && CONFIG.TRANSCODING.HLS.ENABLED === false) {
+      throw new Error('You need to enable at least Web Video transcoding or HLS transcoding.')
     }
 
     if (CONFIG.TRANSCODING.CONCURRENCY <= 0) {
@@ -264,7 +290,7 @@ function checkLiveConfig () {
 function checkObjectStorageConfig () {
   if (CONFIG.OBJECT_STORAGE.ENABLED === true) {
 
-    if (!CONFIG.OBJECT_STORAGE.VIDEOS.BUCKET_NAME) {
+    if (!CONFIG.OBJECT_STORAGE.WEB_VIDEOS.BUCKET_NAME) {
       throw new Error('videos_bucket should be set when object storage support is enabled.')
     }
 
@@ -273,10 +299,10 @@ function checkObjectStorageConfig () {
     }
 
     if (
-      CONFIG.OBJECT_STORAGE.VIDEOS.BUCKET_NAME === CONFIG.OBJECT_STORAGE.STREAMING_PLAYLISTS.BUCKET_NAME &&
-      CONFIG.OBJECT_STORAGE.VIDEOS.PREFIX === CONFIG.OBJECT_STORAGE.STREAMING_PLAYLISTS.PREFIX
+      CONFIG.OBJECT_STORAGE.WEB_VIDEOS.BUCKET_NAME === CONFIG.OBJECT_STORAGE.STREAMING_PLAYLISTS.BUCKET_NAME &&
+      CONFIG.OBJECT_STORAGE.WEB_VIDEOS.PREFIX === CONFIG.OBJECT_STORAGE.STREAMING_PLAYLISTS.PREFIX
     ) {
-      if (CONFIG.OBJECT_STORAGE.VIDEOS.PREFIX === '') {
+      if (CONFIG.OBJECT_STORAGE.WEB_VIDEOS.PREFIX === '') {
         throw new Error('Object storage bucket prefixes should be set when the same bucket is used for both types of video.')
       }
 
diff --git a/server/initializers/checker-before-init.ts b/server/initializers/checker-before-init.ts
index 0a315ea70..a872fcba3 100644
--- a/server/initializers/checker-before-init.ts
+++ b/server/initializers/checker-before-init.ts
@@ -18,7 +18,7 @@ function checkMissedConfig () {
     'database.hostname', 'database.port', 'database.username', 'database.password', 'database.pool.max',
     'smtp.hostname', 'smtp.port', 'smtp.username', 'smtp.password', 'smtp.tls', 'smtp.from_address',
     'email.body.signature', 'email.subject.prefix',
-    'storage.avatars', 'storage.videos', 'storage.logs', 'storage.previews', 'storage.thumbnails', 'storage.torrents', 'storage.cache',
+    'storage.avatars', 'storage.web_videos', 'storage.logs', 'storage.previews', 'storage.thumbnails', 'storage.torrents', 'storage.cache',
     'storage.redundancy', 'storage.tmp', 'storage.streaming_playlists', 'storage.plugins', 'storage.well_known',
     'log.level', 'log.rotation.enabled', 'log.rotation.max_file_size', 'log.rotation.max_files', 'log.anonymize_ip',
     'log.log_ping_requests', 'log.log_tracker_unknown_infohash', 'log.prettify_sql', 'log.accept_client_log',
@@ -29,12 +29,13 @@ function checkMissedConfig () {
     'video_channels.max_per_user',
     'csp.enabled', 'csp.report_only', 'csp.report_uri',
     'security.frameguard.enabled', 'security.powered_by_header.enabled',
-    'cache.previews.size', 'cache.captions.size', 'cache.torrents.size', 'admin.email', 'contact_form.enabled',
+    'cache.previews.size', 'cache.captions.size', 'cache.torrents.size', 'cache.storyboards.size',
+    'admin.email', 'contact_form.enabled',
     'signup.enabled', 'signup.limit', 'signup.requires_approval', 'signup.requires_email_verification', 'signup.minimum_age',
     'signup.filters.cidr.whitelist', 'signup.filters.cidr.blacklist',
     'redundancy.videos.strategies', 'redundancy.videos.check_interval',
-    'transcoding.enabled', 'transcoding.threads', 'transcoding.allow_additional_extensions', 'transcoding.hls.enabled',
-    'transcoding.profile', 'transcoding.concurrency',
+    'transcoding.enabled', 'transcoding.threads', 'transcoding.allow_additional_extensions', 'transcoding.web_videos.enabled',
+    'transcoding.hls.enabled', 'transcoding.profile', 'transcoding.concurrency',
     'transcoding.resolutions.0p', 'transcoding.resolutions.144p', 'transcoding.resolutions.240p', 'transcoding.resolutions.360p',
     'transcoding.resolutions.480p', 'transcoding.resolutions.720p', 'transcoding.resolutions.1080p', 'transcoding.resolutions.1440p',
     'transcoding.resolutions.2160p', 'transcoding.always_transcode_original_resolution', 'transcoding.remote_runners.enabled',
@@ -59,8 +60,8 @@ function checkMissedConfig () {
     'object_storage.enabled', 'object_storage.endpoint', 'object_storage.region', 'object_storage.upload_acl.public',
     'object_storage.upload_acl.private', 'object_storage.proxy.proxify_private_files', 'object_storage.credentials.access_key_id',
     'object_storage.credentials.secret_access_key', 'object_storage.max_upload_part', 'object_storage.streaming_playlists.bucket_name',
-    'object_storage.streaming_playlists.prefix', 'object_storage.streaming_playlists.base_url', 'object_storage.videos.bucket_name',
-    'object_storage.videos.prefix', 'object_storage.videos.base_url',
+    'object_storage.streaming_playlists.prefix', 'object_storage.streaming_playlists.base_url', 'object_storage.web_videos.bucket_name',
+    'object_storage.web_videos.prefix', 'object_storage.web_videos.base_url',
     'theme.default',
     'feeds.videos.count', 'feeds.comments.count',
     'geo_ip.enabled', 'geo_ip.country.database_url',
diff --git a/server/initializers/config.ts b/server/initializers/config.ts
index 51ac5d0ce..37cd852f1 100644
--- a/server/initializers/config.ts
+++ b/server/initializers/config.ts
@@ -106,12 +106,13 @@ const CONFIG = {
     TMP_DIR: buildPath(config.get<string>('storage.tmp')),
     TMP_PERSISTENT_DIR: buildPath(config.get<string>('storage.tmp_persistent')),
     BIN_DIR: buildPath(config.get<string>('storage.bin')),
-    ACTOR_IMAGES: buildPath(config.get<string>('storage.avatars')),
+    ACTOR_IMAGES_DIR: buildPath(config.get<string>('storage.avatars')),
     LOG_DIR: buildPath(config.get<string>('storage.logs')),
-    VIDEOS_DIR: buildPath(config.get<string>('storage.videos')),
+    WEB_VIDEOS_DIR: buildPath(config.get<string>('storage.web_videos')),
     STREAMING_PLAYLISTS_DIR: buildPath(config.get<string>('storage.streaming_playlists')),
     REDUNDANCY_DIR: buildPath(config.get<string>('storage.redundancy')),
     THUMBNAILS_DIR: buildPath(config.get<string>('storage.thumbnails')),
+    STORYBOARDS_DIR: buildPath(config.get<string>('storage.storyboards')),
     PREVIEWS_DIR: buildPath(config.get<string>('storage.previews')),
     CAPTIONS_DIR: buildPath(config.get<string>('storage.captions')),
     TORRENTS_DIR: buildPath(config.get<string>('storage.torrents')),
@@ -139,10 +140,10 @@ const CONFIG = {
     PROXY: {
       PROXIFY_PRIVATE_FILES: config.get<boolean>('object_storage.proxy.proxify_private_files')
     },
-    VIDEOS: {
-      BUCKET_NAME: config.get<string>('object_storage.videos.bucket_name'),
-      PREFIX: config.get<string>('object_storage.videos.prefix'),
-      BASE_URL: config.get<string>('object_storage.videos.base_url')
+    WEB_VIDEOS: {
+      BUCKET_NAME: config.get<string>('object_storage.web_videos.bucket_name'),
+      PREFIX: config.get<string>('object_storage.web_videos.prefix'),
+      BASE_URL: config.get<string>('object_storage.web_videos.base_url')
     },
     STREAMING_PLAYLISTS: {
       BUCKET_NAME: config.get<string>('object_storage.streaming_playlists.bucket_name'),
@@ -370,8 +371,8 @@ const CONFIG = {
     HLS: {
       get ENABLED () { return config.get<boolean>('transcoding.hls.enabled') }
     },
-    WEBTORRENT: {
-      get ENABLED () { return config.get<boolean>('transcoding.webtorrent.enabled') }
+    WEB_VIDEOS: {
+      get ENABLED () { return config.get<boolean>('transcoding.web_videos.enabled') }
     },
     REMOTE_RUNNERS: {
       get ENABLED () { return config.get<boolean>('transcoding.remote_runners.enabled') }
@@ -482,6 +483,9 @@ const CONFIG = {
     },
     TORRENTS: {
       get SIZE () { return config.get<number>('cache.torrents.size') }
+    },
+    STORYBOARDS: {
+      get SIZE () { return config.get<number>('cache.storyboards.size') }
     }
   },
   INSTANCE: {
@@ -580,16 +584,6 @@ function isEmailEnabled () {
   return false
 }
 
-// ---------------------------------------------------------------------------
-
-export {
-  CONFIG,
-  registerConfigChangedHandler,
-  isEmailEnabled
-}
-
-// ---------------------------------------------------------------------------
-
 function getLocalConfigFilePath () {
   const localConfigDir = getLocalConfigDir()
 
@@ -600,6 +594,17 @@ function getLocalConfigFilePath () {
   return join(localConfigDir, filename + '.json')
 }
 
+// ---------------------------------------------------------------------------
+
+export {
+  CONFIG,
+  getLocalConfigFilePath,
+  registerConfigChangedHandler,
+  isEmailEnabled
+}
+
+// ---------------------------------------------------------------------------
+
 function getLocalConfigDir () {
   if (process.env.PEERTUBE_LOCAL_CONFIG) return process.env.PEERTUBE_LOCAL_CONFIG
 
diff --git a/server/initializers/constants.ts b/server/initializers/constants.ts
index a92fd22d6..03ae94d35 100644
--- a/server/initializers/constants.ts
+++ b/server/initializers/constants.ts
@@ -27,7 +27,7 @@ import { CONFIG, registerConfigChangedHandler } from './config'
 
 // ---------------------------------------------------------------------------
 
-const LAST_MIGRATION_VERSION = 780
+const LAST_MIGRATION_VERSION = 790
 
 // ---------------------------------------------------------------------------
 
@@ -76,6 +76,8 @@ const SORTABLE_COLUMNS = {
   VIDEO_COMMENT_THREADS: [ 'createdAt', 'totalReplies' ],
   VIDEO_COMMENTS: [ 'createdAt' ],
 
+  VIDEO_PASSWORDS: [ 'createdAt' ],
+
   VIDEO_RATES: [ 'createdAt' ],
   BLACKLISTS: [ 'id', 'name', 'duration', 'views', 'likes', 'dislikes', 'uuid', 'createdAt' ],
 
@@ -172,6 +174,7 @@ const JOB_ATTEMPTS: { [id in JobType]: number } = {
   'after-video-channel-import': 1,
   'move-to-object-storage': 3,
   'transcoding-job-builder': 1,
+  'generate-video-storyboard': 1,
   'notify': 1,
   'federate-video': 1
 }
@@ -196,6 +199,7 @@ const JOB_CONCURRENCY: { [id in Exclude<JobType, 'video-transcoding' | 'video-im
   'video-channel-import': 1,
   'after-video-channel-import': 1,
   'transcoding-job-builder': 1,
+  'generate-video-storyboard': 1,
   'notify': 5,
   'federate-video': 3
 }
@@ -216,6 +220,7 @@ const JOB_TTL: { [id in JobType]: number } = {
   'activitypub-refresher': 60000 * 10, // 10 minutes
   'video-redundancy': 1000 * 3600 * 3, // 3 hours
   'video-live-ending': 1000 * 60 * 10, // 10 minutes
+  'generate-video-storyboard': 1000 * 60 * 10, // 10 minutes
   'manage-video-torrent': 1000 * 3600 * 3, // 3 hours
   'move-to-object-storage': 1000 * 60 * 60 * 3, // 3 hours
   'video-channel-import': 1000 * 60 * 60 * 4, // 4 hours
@@ -444,6 +449,9 @@ const CONSTRAINTS_FIELDS = {
     REASON: { min: 1, max: 5000 }, // Length
     ERROR_MESSAGE: { min: 1, max: 5000 }, // Length
     PROGRESS: { min: 0, max: 100 } // Value
+  },
+  VIDEO_PASSWORD: {
+    LENGTH: { min: 2, max: 100 }
   }
 }
 
@@ -520,7 +528,8 @@ const VIDEO_PRIVACIES: { [ id in VideoPrivacy ]: string } = {
   [VideoPrivacy.PUBLIC]: 'Public',
   [VideoPrivacy.UNLISTED]: 'Unlisted',
   [VideoPrivacy.PRIVATE]: 'Private',
-  [VideoPrivacy.INTERNAL]: 'Internal'
+  [VideoPrivacy.INTERNAL]: 'Internal',
+  [VideoPrivacy.PASSWORD_PROTECTED]: 'Password protected'
 }
 
 const VIDEO_STATES: { [ id in VideoState ]: string } = {
@@ -738,10 +747,16 @@ const NSFW_POLICY_TYPES: { [ id: string ]: NSFWPolicyType } = {
 
 // Express static paths (router)
 const STATIC_PATHS = {
+  // TODO: deprecated in v6, to remove
   THUMBNAILS: '/static/thumbnails/',
 
-  WEBSEED: '/static/webseed/',
-  PRIVATE_WEBSEED: '/static/webseed/private/',
+  // Need to keep this legacy path for previously generated torrents
+  LEGACY_WEB_VIDEOS: '/static/webseed/',
+  WEB_VIDEOS: '/static/web-videos/',
+
+  // Need to keep this legacy path for previously generated torrents
+  LEGACY_PRIVATE_WEB_VIDEOS: '/static/webseed/private/',
+  PRIVATE_WEB_VIDEOS: '/static/web-videos/private/',
 
   REDUNDANCY: '/static/redundancy/',
 
@@ -756,14 +771,18 @@ const STATIC_DOWNLOAD_PATHS = {
   HLS_VIDEOS: '/download/streaming-playlists/hls/videos/'
 }
 const LAZY_STATIC_PATHS = {
+  THUMBNAILS: '/lazy-static/thumbnails/',
   BANNERS: '/lazy-static/banners/',
   AVATARS: '/lazy-static/avatars/',
   PREVIEWS: '/lazy-static/previews/',
   VIDEO_CAPTIONS: '/lazy-static/video-captions/',
-  TORRENTS: '/lazy-static/torrents/'
+  TORRENTS: '/lazy-static/torrents/',
+  STORYBOARDS: '/lazy-static/storyboards/'
 }
 const OBJECT_STORAGE_PROXY_PATHS = {
-  PRIVATE_WEBSEED: '/object-storage-proxy/webseed/private/',
+  // Need to keep this legacy path for previously generated torrents
+  LEGACY_PRIVATE_WEB_VIDEOS: '/object-storage-proxy/webseed/private/',
+  PRIVATE_WEB_VIDEOS: '/object-storage-proxy/web-videos/private/',
 
   STREAMING_PLAYLISTS: {
     PRIVATE_HLS: '/object-storage-proxy/streaming-playlists/hls/private/'
@@ -807,6 +826,14 @@ const ACTOR_IMAGES_SIZE: { [key in ActorImageType]: { width: number, height: num
   ]
 }
 
+const STORYBOARD = {
+  SPRITE_SIZE: {
+    width: 192,
+    height: 108
+  },
+  SPRITES_MAX_EDGE_COUNT: 10
+}
+
 const EMBED_SIZE = {
   width: 560,
   height: 315
@@ -818,6 +845,10 @@ const FILES_CACHE = {
     DIRECTORY: join(CONFIG.STORAGE.CACHE_DIR, 'previews'),
     MAX_AGE: 1000 * 3600 * 3 // 3 hours
   },
+  STORYBOARDS: {
+    DIRECTORY: join(CONFIG.STORAGE.CACHE_DIR, 'storyboards'),
+    MAX_AGE: 1000 * 3600 * 24 // 24 hours
+  },
   VIDEO_CAPTIONS: {
     DIRECTORY: join(CONFIG.STORAGE.CACHE_DIR, 'video-captions'),
     MAX_AGE: 1000 * 3600 * 3 // 3 hours
@@ -832,8 +863,8 @@ const LRU_CACHE = {
   USER_TOKENS: {
     MAX_SIZE: 1000
   },
-  ACTOR_IMAGE_STATIC: {
-    MAX_SIZE: 500
+  FILENAME_TO_PATH_PERMANENT_FILE_CACHE: {
+    MAX_SIZE: 1000
   },
   STATIC_VIDEO_FILES_RIGHTS_CHECK: {
     MAX_SIZE: 5000,
@@ -857,8 +888,8 @@ const DIRECTORIES = {
   },
 
   VIDEOS: {
-    PUBLIC: CONFIG.STORAGE.VIDEOS_DIR,
-    PRIVATE: join(CONFIG.STORAGE.VIDEOS_DIR, 'private')
+    PUBLIC: CONFIG.STORAGE.WEB_VIDEOS_DIR,
+    PRIVATE: join(CONFIG.STORAGE.WEB_VIDEOS_DIR, 'private')
   },
 
   HLS_REDUNDANCY: join(CONFIG.STORAGE.REDUNDANCY_DIR, 'hls')
@@ -1084,6 +1115,7 @@ export {
   RESUMABLE_UPLOAD_SESSION_LIFETIME,
   RUNNER_JOB_STATES,
   P2P_MEDIA_LOADER_PEER_VERSION,
+  STORYBOARD,
   ACTOR_IMAGES_SIZE,
   ACCEPT_HEADERS,
   BCRYPT_SALT_SIZE,
diff --git a/server/initializers/database.ts b/server/initializers/database.ts
index 14dd8c379..bc120e398 100644
--- a/server/initializers/database.ts
+++ b/server/initializers/database.ts
@@ -10,6 +10,7 @@ import { UserModel } from '@server/models/user/user'
 import { UserNotificationModel } from '@server/models/user/user-notification'
 import { UserRegistrationModel } from '@server/models/user/user-registration'
 import { UserVideoHistoryModel } from '@server/models/user/user-video-history'
+import { StoryboardModel } from '@server/models/video/storyboard'
 import { VideoChannelSyncModel } from '@server/models/video/video-channel-sync'
 import { VideoJobInfoModel } from '@server/models/video/video-job-info'
 import { VideoLiveReplaySettingModel } from '@server/models/video/video-live-replay-setting'
@@ -56,6 +57,7 @@ import { VideoStreamingPlaylistModel } from '../models/video/video-streaming-pla
 import { VideoTagModel } from '../models/video/video-tag'
 import { VideoViewModel } from '../models/view/video-view'
 import { CONFIG } from './config'
+import { VideoPasswordModel } from '@server/models/video/video-password'
 
 require('pg').defaults.parseInt8 = true // Avoid BIGINT to be converted to string
 
@@ -163,9 +165,11 @@ async function initDatabaseModels (silent: boolean) {
     VideoJobInfoModel,
     VideoChannelSyncModel,
     UserRegistrationModel,
+    VideoPasswordModel,
     RunnerRegistrationTokenModel,
     RunnerModel,
-    RunnerJobModel
+    RunnerJobModel,
+    StoryboardModel
   ])
 
   // Check extensions exist in the database
diff --git a/server/initializers/migrations/0785-video-password-protection.ts b/server/initializers/migrations/0785-video-password-protection.ts
new file mode 100644
index 000000000..1d85f4489
--- /dev/null
+++ b/server/initializers/migrations/0785-video-password-protection.ts
@@ -0,0 +1,31 @@
+import * as Sequelize from 'sequelize'
+
+async function up (utils: {
+  transaction: Sequelize.Transaction
+  queryInterface: Sequelize.QueryInterface
+  sequelize: Sequelize.Sequelize
+}): Promise<void> {
+  {
+    const query = `
+      CREATE TABLE IF NOT EXISTS "videoPassword" (
+        "id"   SERIAL,
+        "password" VARCHAR(255) NOT NULL,
+        "videoId" INTEGER NOT NULL REFERENCES "video" ("id") ON DELETE CASCADE ON UPDATE CASCADE,
+        "createdAt" TIMESTAMP WITH TIME ZONE NOT NULL,
+        "updatedAt" TIMESTAMP WITH TIME ZONE NOT NULL,
+        PRIMARY KEY ("id")
+      );
+    `
+
+    await utils.sequelize.query(query, { transaction : utils.transaction })
+  }
+}
+
+function down (options) {
+  throw new Error('Not implemented.')
+}
+
+export {
+  up,
+  down
+}
diff --git a/server/initializers/migrations/0790-thumbnail-disk.ts b/server/initializers/migrations/0790-thumbnail-disk.ts
new file mode 100644
index 000000000..0824c042e
--- /dev/null
+++ b/server/initializers/migrations/0790-thumbnail-disk.ts
@@ -0,0 +1,47 @@
+import * as Sequelize from 'sequelize'
+
+async function up (utils: {
+  transaction: Sequelize.Transaction
+  queryInterface: Sequelize.QueryInterface
+  sequelize: Sequelize.Sequelize
+}): Promise<void> {
+  const { transaction } = utils
+
+  {
+    const data = {
+      type: Sequelize.BOOLEAN,
+      allowNull: true,
+      defaultValue: true
+    }
+
+    await utils.queryInterface.addColumn('thumbnail', 'onDisk', data, { transaction })
+  }
+
+  {
+    // Remote previews are not on the disk
+    await utils.sequelize.query(
+      'UPDATE "thumbnail" SET "onDisk" = FALSE ' +
+      'WHERE "type" = 2 AND "videoId" NOT IN (SELECT "id" FROM "video" WHERE "remote" IS FALSE)',
+      { transaction }
+    )
+  }
+
+  {
+    const data = {
+      type: Sequelize.BOOLEAN,
+      allowNull: false,
+      defaultValue: null
+    }
+
+    await utils.queryInterface.changeColumn('thumbnail', 'onDisk', data, { transaction })
+  }
+}
+
+function down (options) {
+  throw new Error('Not implemented.')
+}
+
+export {
+  up,
+  down
+}
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 { getAPId } from '../activity'
+import { arrayify } from '@shared/core-utils'
+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) {
-  const accountAttributedTo = actorObject.attributedTo.find(a => a.type === 'Person')
-  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}`)
+async function getOrCreateAPOwner (actorObject: ActivityPubActor, actorUrl: string) {
+  const accountAttributedTo = await findOwner(actorUrl, actorObject.attributedTo, 'Person')
+  if (!accountAttributedTo) {
+    throw new Error(`Cannot find account attributed to video channel  ${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) {
-  const videoToCreateData = activity.object as VideoObject
-
+async function processCreateVideo (videoToCreateData: VideoObject, notify: boolean) {
   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) {
-  const watchAction = activity.object as WatchActionObject
-
+async function processCreateWatchAction (watchAction: 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) {
-  const commentObject = activity.object as VideoCommentObject
+async function processCreateVideoComment (
+  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) {
-  const playlistObject = activity.object as PlaylistObject
+async function processCreatePlaylist (
+  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) {
-  const dislikeObject = activity.type === 'Dislike'
-    ? activity.object
-    : (activity.object as DislikeObject).object
-
+async function processDislike (activity: ActivityDislike, byActor: MActorSignature) {
+  const dislikeObject = activity.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) {
-  const flag = activity.type === 'Flag' ? activity : (activity.object as AbuseObject)
-
+async function processCreateAbuse (flag: ActivityFlag, byActor: MActorSignature) {
   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 { DislikeObject } from '../../../../shared/models/activitypub/objects'
+import {
+  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') {
-      return retryTransactionWrapper(processUndoCacheFile, byActor, activity)
+    const objectToUndo = await fetchAPObject<CacheFileObject>(activityToUndo.object)
+
+    if (objectToUndo.type === 'CacheFile') {
+      return retryTransactionWrapper(processUndoCacheFile, byActor, activity, objectToUndo)
     }
   }
 
@@ -53,8 +64,8 @@ export {
 
 // ---------------------------------------------------------------------------
 
-async function processUndoLike (byActor: MActorSignature, activity: ActivityUndo) {
-  const likeActivity = activity.object as ActivityLike
+async function processUndoLike (byActor: MActorSignature, activity: ActivityUndo<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) {
-  const dislike = activity.object.type === 'Dislike'
-    ? activity.object
-    : activity.object.object as DislikeObject
+async function processUndoDislike (byActor: MActorSignature, activity: ActivityUndo<ActivityDislike>) {
+  const dislikeActivity = activity.object
 
-  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) {
-  const cacheFileObject = activity.object.object as CacheFileObject
-
+async function processUndoCacheFile (
+  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) {
-  const actorObject = activity.object as ActivityPubActor
-
+async function processUpdateActor (actor: MActorFull, actorObject: 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) {
-  const playlistObject = activity.object as PlaylistObject
+async function processUpdatePlaylist (
+  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 {
-  ActivityAnnounce,
-  ActivityAudience,
-  ActivityCreate,
-  ActivityDislike,
-  ActivityFollow,
-  ActivityLike,
-  ActivityUndo,
-  ContextType
-} from '@shared/models'
+import { ActivityAudience, ActivityDislike, ActivityLike, ActivityUndo, ActivityUndoObject, 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,
-  MVideoAPWithoutCaption,
+  MVideoAPLight,
   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) {
-  const video = videoArg as MVideoAP
+async function sendUpdateVideo (videoArg: MVideoAPLight, transaction: Transaction, overriddenByActor?: MActor) {
+  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, MVideoAPWithoutCaption } from '@server/types/models'
+import { MVideoAP, MVideoAPLight } 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
-    if (isArray(video.VideoCaptions) === false) {
-      video.VideoCaptions = await video.$get('VideoCaptions', {
-        attributes: [ 'filename', 'language' ],
-        transaction
-      })
-    }
+    const video = await videoArg.lightAPToFullAP(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 { checkUrlsSameHost } from '../../url'
+import { findOwner, getOrCreateAPActor } from '../../actors'
 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> {
-    return updateVideoMiniatureFromUrl({
-      downloadUrl: getThumbnailFromIcons(this.videoObject).url,
-      video,
-      type: ThumbnailType.MINIATURE
-    }).catch(err => {
-      logger.warn('Cannot generate thumbnail of %s.', this.videoObject.id, { err, ...this.lTags() })
-
+  protected async setThumbnail (video: MVideoThumbnail, t?: Transaction) {
+    const miniatureIcon = getThumbnailFromIcons(this.videoObject)
+    if (!miniatureIcon) {
+      logger.warn('Cannot find thumbnail in video object', { object: this.videoObject })
       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
-        videoCreated.VideoChannel = channel
-
-        if (thumbnailModel) await videoCreated.addAndSaveThumbnail(thumbnailModel, t)
-
-        await this.setPreview(videoCreated, t)
-        await this.setWebTorrentFiles(videoCreated, t)
-        await this.setStreamingPlaylists(videoCreated, t)
-        await this.setTags(videoCreated, t)
-        await this.setTrackers(videoCreated, t)
-        await this.insertOrReplaceCaptions(videoCreated, t)
-        await this.insertOrReplaceLive(videoCreated, t)
-
-        // We added a video in this channel, set it as updated
-        await channel.setAsUpdated(t)
-
-        const autoBlacklisted = await autoBlacklistVideoIfNeeded({
-          video: videoCreated,
-          user: undefined,
-          isRemote: true,
-          isNew: true,
-          transaction: t
-        })
-
-        logger.info('Remote video with uuid %s inserted.', this.videoObject.uuid, this.lTags())
+      const videoCreated = await video.save({ transaction: t }) as MVideoFullLight
+      videoCreated.VideoChannel = channel
+
+      await this.setThumbnail(videoCreated, t)
+      await this.setPreview(videoCreated, t)
+      await this.setWebVideoFiles(videoCreated, t)
+      await this.setStreamingPlaylists(videoCreated, t)
+      await this.setTags(videoCreated, t)
+      await this.setTrackers(videoCreated, t)
+      await this.insertOrReplaceCaptions(videoCreated, t)
+      await this.insertOrReplaceLive(videoCreated, t)
+      await this.insertOrReplaceStoryboard(videoCreated, t)
+
+      // We added a video in this channel, set it as updated
+      await channel.setAsUpdated(t)
+
+      const autoBlacklisted = await autoBlacklistVideoIfNeeded({
+        video: videoCreated,
+        user: undefined,
+        isRemote: true,
+        isNew: true,
+        transaction: t
+      })
 
-        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 }
-      } catch (err) {
-        // FIXME: Use rollback hook when https://github.com/sequelize/sequelize/pull/13038 is released
-        if (thumbnailModel) await thumbnailModel.removeThumbnail()
+      Hooks.runAction('action:activity-pub.remote-video.created', { video: videoCreated, videoAPObject: this.videoObject })
 
-        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),
-        this.setPreview(videoUpdated)
+        runInReadCommittedTransaction(t => this.setStoryboard(videoUpdated, t)),
+        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 './videos-caption-cache'
-export * from './videos-torrent-cache'
+export * from './avatar-permanent-file-cache'
+export * from './video-miniature-permanent-file-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 { CONSTRAINTS_FIELDS } from '@server/initializers/constants'
+import { JobQueue } from '../job-queue'
 
 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 { removeAllWebTorrentFiles } from '@server/lib/video-file'
+import { mergeAudioVideofile, optimizeOriginalVideofile, transcodeNewWebVideoResolution } from '@server/lib/transcoding/web-transcoding'
+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,
-  'merge-audio-to-webtorrent': handleWebTorrentMergeAudioJob,
-  'optimize-to-webtorrent': handleWebTorrentOptimizeJob
+  'new-resolution-to-web-video': handleNewWebVideoResolutionJob,
+  'merge-audio-to-web-video': handleWebVideoMergeAudioJob,
+  '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) {
-  logger.info('Handling WebTorrent transcoding job for %s.', video.uuid, lTags(video.uuid), { payload })
+async function handleNewWebVideoResolutionJob (job: Job, payload: NewWebVideoResolutionTranscodingPayload, video: MVideoFullLight) {
+  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) {
-    logger.info('Removing WebTorrent files of %s now we have a HLS version of it.', video.uuid, lTags(video.uuid))
+  if (payload.deleteWebVideoFiles === true) {
+    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) {
-  const baseUrl = CONFIG.OBJECT_STORAGE.VIDEOS.BASE_URL
+function getWebVideoPublicFileUrl (fileUrl: string) {
+  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) {
-  return WEBSERVER.URL + OBJECT_STORAGE_PROXY_PATHS.PRIVATE_WEBSEED + filename
+function getWebVideoPrivateFileUrl (filename: string) {
+  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),
-    bucketInfo: CONFIG.OBJECT_STORAGE.VIDEOS,
+    objectStorageKey: generateWebVideoObjectStorageKey(file.filename),
+    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),
-    bucketInfo: CONFIG.OBJECT_STORAGE.VIDEOS,
+    objectStorageKey: generateWebVideoObjectStorageKey(file.filename),
+    bucketInfo: CONFIG.OBJECT_STORAGE.WEB_VIDEOS,
     isPrivate: video.hasPrivateStaticPath()
   })
 }
@@ -102,8 +102,8 @@ function removeHLSFileObjectStorageByFullKey (key: string) {
 
 // ---------------------------------------------------------------------------
 
-function removeWebTorrentObjectStorage (videoFile: MVideoFile) {
-  return removeObject(generateWebTorrentObjectStorageKey(videoFile.filename), CONFIG.OBJECT_STORAGE.VIDEOS)
+function removeWebVideoObjectStorage (videoFile: MVideoFile) {
+  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) {
-  const key = generateWebTorrentObjectStorageKey(filename)
+async function makeWebVideoFileAvailable (filename: string, destination: string) {
+  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: {
-          videoFiles: webtorrentVideoFiles
+        webtorrent: { // TODO: remove in v7
+          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: {
-          enabled: CONFIG.TRANSCODING.ENABLED && CONFIG.TRANSCODING.WEBTORRENT.ENABLED
+        web_videos: {
+          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: {
-  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: {
+function updateLocalVideoMiniatureFromExisting (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 { filename: updatedFilename, height, width, existingThumbnail } = buildMetadataFromVideo(video, type, size)
+  const { downloadUrl, video, type, size } = options
+  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,
-  updateVideoMiniatureFromUrl,
-  updateVideoMiniatureFromExisting,
-  updatePlaceholderThumbnail,
-  updatePlaylistMiniatureFromUrl,
-  updatePlaylistMiniatureFromExisting
+  generateLocalVideoMiniature,
+  updateLocalVideoMiniatureFromUrl,
+  updateLocalVideoMiniatureFromExisting,
+  updateRemoteVideoThumbnail,
+  updateRemotePlaylistMiniatureFromUrl,
+  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') {
-        return this.buildWebTorrentJobPayload({ videoUUID: video.uuid, resolution, fps, isNewVideo })
+      if (transcodingType === 'webtorrent' || transcodingType === 'web-video') {
+        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)
-    children: (HLSTranscodingPayload | NewWebTorrentResolutionTranscodingPayload)[]
+    parent: (HLSTranscodingPayload | NewWebVideoResolutionTranscodingPayload)
+    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) {
-        const payloads: (NewWebTorrentResolutionTranscodingPayload | HLSTranscodingPayload)[] = [
-          this.buildWebTorrentJobPayload({
+      if (CONFIG.TRANSCODING.WEB_VIDEOS.ENABLED) {
+        const payloads: (NewWebVideoResolutionTranscodingPayload | HLSTranscodingPayload)[] = [
+          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
-export async function transcodeNewWebTorrentResolution (options: {
+// Transcode the original video file to a lower resolution compatible with web browsers
+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 })
-    if (oldFile) await video.removeWebTorrentFile(oldFile)
+    const oldFile = await VideoFileModel.loadWebVideoFile({ videoId: video.id, fps: videoFile.fps, resolution: videoFile.resolution })
+    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,
-  removeWebTorrentFile,
+  removeAllWebVideoFiles,
+  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) {
-  return privacy === VideoPrivacy.PRIVATE || privacy === VideoPrivacy.INTERNAL
+function isVideoInPrivateDirectory (privacy) {
+  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) {
-  const directories = getWebTorrentDirectories(type)
+async function moveWebVideoFileOnFS (type: MoveType, video: MVideo, file: MVideoFile) {
+  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 expires = new Date(new Date().getTime() + LRU_CACHE.VIDEO_TOKENS.TTL)
+    const { token, expires } = this.generateVideoToken()
 
     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
diff --git a/server/middlewares/auth.ts b/server/middlewares/auth.ts
index 0eefa2a8e..39a7b2998 100644
--- a/server/middlewares/auth.ts
+++ b/server/middlewares/auth.ts
@@ -5,6 +5,7 @@ import { RunnerModel } from '@server/models/runner/runner'
 import { HttpStatusCode } from '../../shared/models/http/http-error-codes'
 import { logger } from '../helpers/logger'
 import { handleOAuthAuthenticate } from '../lib/auth/oauth'
+import { ServerErrorCode } from '@shared/models'
 
 function authenticate (req: express.Request, res: express.Response, next: express.NextFunction) {
   handleOAuthAuthenticate(req, res)
@@ -48,15 +49,23 @@ function authenticateSocket (socket: Socket, next: (err?: any) => void) {
     .catch(err => logger.error('Cannot get access token.', { err }))
 }
 
-function authenticatePromise (req: express.Request, res: express.Response) {
+function authenticatePromise (options: {
+  req: express.Request
+  res: express.Response
+  errorMessage?: string
+  errorStatus?: HttpStatusCode
+  errorType?: ServerErrorCode
+}) {
+  const { req, res, errorMessage = 'Not authenticated', errorStatus = HttpStatusCode.UNAUTHORIZED_401, errorType } = options
   return new Promise<void>(resolve => {
     // Already authenticated? (or tried to)
     if (res.locals.oauth?.token.User) return resolve()
 
     if (res.locals.authenticated === false) {
       return res.fail({
-        status: HttpStatusCode.UNAUTHORIZED_401,
-        message: 'Not authenticated'
+        status: errorStatus,
+        type: errorType,
+        message: errorMessage
       })
     }
 
diff --git a/server/middlewares/validators/config.ts b/server/middlewares/validators/config.ts
index a0074cb24..a6dbba524 100644
--- a/server/middlewares/validators/config.ts
+++ b/server/middlewares/validators/config.ts
@@ -25,6 +25,7 @@ const customConfigUpdateValidator = [
   body('cache.previews.size').isInt(),
   body('cache.captions.size').isInt(),
   body('cache.torrents.size').isInt(),
+  body('cache.storyboards.size').isInt(),
 
   body('signup.enabled').isBoolean(),
   body('signup.limit').isInt(),
@@ -58,7 +59,7 @@ const customConfigUpdateValidator = [
 
   body('transcoding.alwaysTranscodeOriginalResolution').isBoolean(),
 
-  body('transcoding.webtorrent.enabled').isBoolean(),
+  body('transcoding.webVideos.enabled').isBoolean(),
   body('transcoding.hls.enabled').isBoolean(),
 
   body('videoStudio.enabled').isBoolean(),
@@ -152,8 +153,8 @@ function checkInvalidConfigIfEmailDisabled (customConfig: CustomConfig, res: exp
 function checkInvalidTranscodingConfig (customConfig: CustomConfig, res: express.Response) {
   if (customConfig.transcoding.enabled === false) return true
 
-  if (customConfig.transcoding.webtorrent.enabled === false && customConfig.transcoding.hls.enabled === false) {
-    res.fail({ message: 'You need to enable at least webtorrent transcoding or hls transcoding' })
+  if (customConfig.transcoding.webVideos.enabled === false && customConfig.transcoding.hls.enabled === false) {
+    res.fail({ message: 'You need to enable at least web_videos transcoding or hls transcoding' })
     return false
   }
 
diff --git a/server/middlewares/validators/shared/index.ts b/server/middlewares/validators/shared/index.ts
index de98cd442..e5cff2dda 100644
--- a/server/middlewares/validators/shared/index.ts
+++ b/server/middlewares/validators/shared/index.ts
@@ -10,4 +10,5 @@ export * from './video-comments'
 export * from './video-imports'
 export * from './video-ownerships'
 export * from './video-playlists'
+export * from './video-passwords'
 export * from './videos'
diff --git a/server/middlewares/validators/shared/video-passwords.ts b/server/middlewares/validators/shared/video-passwords.ts
new file mode 100644
index 000000000..efcc95dc4
--- /dev/null
+++ b/server/middlewares/validators/shared/video-passwords.ts
@@ -0,0 +1,80 @@
+import express from 'express'
+import { HttpStatusCode, UserRight, VideoPrivacy } from '@shared/models'
+import { forceNumber } from '@shared/core-utils'
+import { VideoPasswordModel } from '@server/models/video/video-password'
+import { header } from 'express-validator'
+import { getVideoWithAttributes } from '@server/helpers/video'
+
+function isValidVideoPasswordHeader () {
+  return header('x-peertube-video-password')
+    .optional()
+    .isString()
+}
+
+function checkVideoIsPasswordProtected (res: express.Response) {
+  const video = getVideoWithAttributes(res)
+  if (video.privacy !== VideoPrivacy.PASSWORD_PROTECTED) {
+    res.fail({
+      status: HttpStatusCode.BAD_REQUEST_400,
+      message: 'Video is not password protected'
+    })
+    return false
+  }
+
+  return true
+}
+
+async function doesVideoPasswordExist (idArg: number | string, res: express.Response) {
+  const video = getVideoWithAttributes(res)
+  const id = forceNumber(idArg)
+  const videoPassword = await VideoPasswordModel.loadByIdAndVideo({ id, videoId: video.id })
+
+  if (!videoPassword) {
+    res.fail({
+      status: HttpStatusCode.NOT_FOUND_404,
+      message: 'Video password not found'
+    })
+    return false
+  }
+
+  res.locals.videoPassword = videoPassword
+
+  return true
+}
+
+async function isVideoPasswordDeletable (res: express.Response) {
+  const user = res.locals.oauth.token.User
+  const userAccount = user.Account
+  const video = res.locals.videoAll
+
+  // Check if the user who did the request is able to delete the video passwords
+  if (
+    user.hasRight(UserRight.UPDATE_ANY_VIDEO) === false && // Not a moderator
+    video.VideoChannel.accountId !== userAccount.id // Not the video owner
+  ) {
+    res.fail({
+      status: HttpStatusCode.FORBIDDEN_403,
+      message: 'Cannot remove passwords of another user\'s video'
+    })
+    return false
+  }
+
+  const passwordCount = await VideoPasswordModel.countByVideoId(video.id)
+
+  if (passwordCount <= 1) {
+    res.fail({
+      status: HttpStatusCode.BAD_REQUEST_400,
+      message: 'Cannot delete the last password of the protected video'
+    })
+    return false
+  }
+
+  return true
+}
+
+export {
+  isValidVideoPasswordHeader,
+  checkVideoIsPasswordProtected as isVideoPasswordProtected,
+  doesVideoPasswordExist,
+  isVideoPasswordDeletable
+}
diff --git a/server/middlewares/validators/shared/videos.ts b/server/middlewares/validators/shared/videos.ts
index 0033a32ff..9a7497007 100644
--- a/server/middlewares/validators/shared/videos.ts
+++ b/server/middlewares/validators/shared/videos.ts
@@ -20,6 +20,8 @@ import {
   MVideoWithRights
 } from '@server/types/models'
 import { HttpStatusCode, ServerErrorCode, UserRight, VideoPrivacy } from '@shared/models'
+import { VideoPasswordModel } from '@server/models/video/video-password'
+import { exists } from '@server/helpers/custom-validators/misc'
 
 async function doesVideoExist (id: number | string, res: Response, fetchType: VideoLoadType = 'all') {
   const userId = res.locals.oauth ? res.locals.oauth.token.User.id : undefined
@@ -111,8 +113,12 @@ async function checkCanSeeVideo (options: {
 }) {
   const { req, res, video, paramId } = options
 
-  if (video.requiresAuth({ urlParamId: paramId, checkBlacklist: true })) {
-    return checkCanSeeAuthVideo(req, res, video)
+  if (video.requiresUserAuth({ urlParamId: paramId, checkBlacklist: true })) {
+    return checkCanSeeUserAuthVideo({ req, res, video })
+  }
+
+  if (video.privacy === VideoPrivacy.PASSWORD_PROTECTED) {
+    return checkCanSeePasswordProtectedVideo({ req, res, video })
   }
 
   if (video.privacy === VideoPrivacy.UNLISTED || video.privacy === VideoPrivacy.PUBLIC) {
@@ -122,7 +128,13 @@ async function checkCanSeeVideo (options: {
   throw new Error('Unknown video privacy when checking video right ' + video.url)
 }
 
-async function checkCanSeeAuthVideo (req: Request, res: Response, video: MVideoId | MVideoWithRights) {
+async function checkCanSeeUserAuthVideo (options: {
+  req: Request
+  res: Response
+  video: MVideoId | MVideoWithRights
+}) {
+  const { req, res, video } = options
+
   const fail = () => {
     res.fail({
       status: HttpStatusCode.FORBIDDEN_403,
@@ -132,14 +144,12 @@ async function checkCanSeeAuthVideo (req: Request, res: Response, video: MVideoI
     return false
   }
 
-  await authenticatePromise(req, res)
+  await authenticatePromise({ req, res })
 
   const user = res.locals.oauth?.token.User
   if (!user) return fail()
 
-  const videoWithRights = (video as MVideoWithRights).VideoChannel?.Account?.userId
-    ? video as MVideoWithRights
-    : await VideoModel.loadFull(video.id)
+  const videoWithRights = await getVideoWithRights(video as MVideoWithRights)
 
   const privacy = videoWithRights.privacy
 
@@ -148,16 +158,14 @@ async function checkCanSeeAuthVideo (req: Request, res: Response, video: MVideoI
     return true
   }
 
-  const isOwnedByUser = videoWithRights.VideoChannel.Account.userId === user.id
-
   if (videoWithRights.isBlacklisted()) {
-    if (isOwnedByUser || user.hasRight(UserRight.MANAGE_VIDEO_BLACKLIST)) return true
+    if (canUserAccessVideo(user, videoWithRights, UserRight.MANAGE_VIDEO_BLACKLIST)) return true
 
     return fail()
   }
 
   if (privacy === VideoPrivacy.PRIVATE || privacy === VideoPrivacy.UNLISTED) {
-    if (isOwnedByUser || user.hasRight(UserRight.SEE_ALL_VIDEOS)) return true
+    if (canUserAccessVideo(user, videoWithRights, UserRight.SEE_ALL_VIDEOS)) return true
 
     return fail()
   }
@@ -166,6 +174,59 @@ async function checkCanSeeAuthVideo (req: Request, res: Response, video: MVideoI
   return fail()
 }
 
+async function checkCanSeePasswordProtectedVideo (options: {
+  req: Request
+  res: Response
+  video: MVideo
+}) {
+  const { req, res, video } = options
+
+  const videoWithRights = await getVideoWithRights(video as MVideoWithRights)
+
+  const videoPassword = req.header('x-peertube-video-password')
+
+  if (!exists(videoPassword)) {
+    const errorMessage = 'Please provide a password to access this password protected video'
+    const errorType = ServerErrorCode.VIDEO_REQUIRES_PASSWORD
+
+    if (req.header('authorization')) {
+      await authenticatePromise({ req, res, errorMessage, errorStatus: HttpStatusCode.FORBIDDEN_403, errorType })
+      const user = res.locals.oauth?.token.User
+
+      if (canUserAccessVideo(user, videoWithRights, UserRight.SEE_ALL_VIDEOS)) return true
+    }
+
+    res.fail({
+      status: HttpStatusCode.FORBIDDEN_403,
+      type: errorType,
+      message: errorMessage
+    })
+    return false
+  }
+
+  if (await VideoPasswordModel.isACorrectPassword({ videoId: video.id, password: videoPassword })) return true
+
+  res.fail({
+    status: HttpStatusCode.FORBIDDEN_403,
+    type: ServerErrorCode.INCORRECT_VIDEO_PASSWORD,
+    message: 'Incorrect video password. Access to the video is denied.'
+  })
+
+  return false
+}
+
+function canUserAccessVideo (user: MUser, video: MVideoWithRights | MVideoAccountLight, right: UserRight) {
+  const isOwnedByUser = video.VideoChannel.Account.userId === user.id
+
+  return isOwnedByUser || user.hasRight(right)
+}
+
+async function getVideoWithRights (video: MVideoWithRights): Promise<MVideoWithRights> {
+  return video.VideoChannel?.Account?.userId
+    ? video
+    : VideoModel.loadFull(video.id)
+}
+
 // ---------------------------------------------------------------------------
 
 async function checkCanAccessVideoStaticFiles (options: {
@@ -176,7 +237,7 @@ async function checkCanAccessVideoStaticFiles (options: {
 }) {
   const { video, req, res } = options
 
-  if (res.locals.oauth?.token.User) {
+  if (res.locals.oauth?.token.User || exists(req.header('x-peertube-video-password'))) {
     return checkCanSeeVideo(options)
   }
 
diff --git a/server/middlewares/validators/sort.ts b/server/middlewares/validators/sort.ts
index 959f663ac..07d6cba82 100644
--- a/server/middlewares/validators/sort.ts
+++ b/server/middlewares/validators/sort.ts
@@ -28,6 +28,7 @@ export const pluginsSortValidator = checkSortFactory(SORTABLE_COLUMNS.PLUGINS)
 export const availablePluginsSortValidator = checkSortFactory(SORTABLE_COLUMNS.AVAILABLE_PLUGINS)
 export const videoRedundanciesSortValidator = checkSortFactory(SORTABLE_COLUMNS.VIDEO_REDUNDANCIES)
 export const videoChannelSyncsSortValidator = checkSortFactory(SORTABLE_COLUMNS.VIDEO_CHANNEL_SYNCS)
+export const videoPasswordsSortValidator = checkSortFactory(SORTABLE_COLUMNS.VIDEO_PASSWORDS)
 
 export const accountsFollowersSortValidator = checkSortFactory(SORTABLE_COLUMNS.ACCOUNT_FOLLOWERS)
 export const videoChannelsFollowersSortValidator = checkSortFactory(SORTABLE_COLUMNS.CHANNEL_FOLLOWERS)
diff --git a/server/middlewares/validators/static.ts b/server/middlewares/validators/static.ts
index 9c2d890ba..86cc0a8d7 100644
--- a/server/middlewares/validators/static.ts
+++ b/server/middlewares/validators/static.ts
@@ -9,7 +9,7 @@ import { VideoModel } from '@server/models/video/video'
 import { VideoFileModel } from '@server/models/video/video-file'
 import { MStreamingPlaylist, MVideoFile, MVideoThumbnail } from '@server/types/models'
 import { HttpStatusCode } from '@shared/models'
-import { areValidationErrors, checkCanAccessVideoStaticFiles } from './shared'
+import { areValidationErrors, checkCanAccessVideoStaticFiles, isValidVideoPasswordHeader } from './shared'
 
 type LRUValue = {
   allowed: boolean
@@ -22,9 +22,11 @@ const staticFileTokenBypass = new LRUCache<string, LRUValue>({
   ttl: LRU_CACHE.STATIC_VIDEO_FILES_RIGHTS_CHECK.TTL
 })
 
-const ensureCanAccessVideoPrivateWebTorrentFiles = [
+const ensureCanAccessVideoPrivateWebVideoFiles = [
   query('videoFileToken').optional().custom(exists),
 
+  isValidVideoPasswordHeader(),
+
   async (req: express.Request, res: express.Response, next: express.NextFunction) => {
     if (areValidationErrors(req, res)) return
 
@@ -46,7 +48,7 @@ const ensureCanAccessVideoPrivateWebTorrentFiles = [
       return res.sendStatus(HttpStatusCode.FORBIDDEN_403)
     }
 
-    const result = await isWebTorrentAllowed(req, res)
+    const result = await isWebVideoAllowed(req, res)
 
     staticFileTokenBypass.set(cacheKey, result)
 
@@ -73,6 +75,8 @@ const ensureCanAccessPrivateVideoHLSFiles = [
     .optional()
     .customSanitizer(isSafePeerTubeFilenameWithoutExtension),
 
+  isValidVideoPasswordHeader(),
+
   async (req: express.Request, res: express.Response, next: express.NextFunction) => {
     if (areValidationErrors(req, res)) return
 
@@ -118,13 +122,13 @@ const ensureCanAccessPrivateVideoHLSFiles = [
 ]
 
 export {
-  ensureCanAccessVideoPrivateWebTorrentFiles,
+  ensureCanAccessVideoPrivateWebVideoFiles,
   ensureCanAccessPrivateVideoHLSFiles
 }
 
 // ---------------------------------------------------------------------------
 
-async function isWebTorrentAllowed (req: express.Request, res: express.Response) {
+async function isWebVideoAllowed (req: express.Request, res: express.Response) {
   const filename = basename(req.path)
 
   const file = await VideoFileModel.loadWithVideoByFilename(filename)
@@ -167,11 +171,11 @@ async function isHLSAllowed (req: express.Request, res: express.Response, videoU
 }
 
 function extractTokenOrDie (req: express.Request, res: express.Response) {
-  const token = res.locals.oauth?.token.accessToken || req.query.videoFileToken
+  const token = req.header('x-peertube-video-password') || req.query.videoFileToken || res.locals.oauth?.token.accessToken
 
   if (!token) {
     return res.fail({
-      message: 'Bearer token is missing in headers or video file token is missing in URL query parameters',
+      message: 'Video password header, video file token query parameter and bearer token are all missing', //
       status: HttpStatusCode.FORBIDDEN_403
     })
   }
diff --git a/server/middlewares/validators/videos/index.ts b/server/middlewares/validators/videos/index.ts
index d225dfe45..0c824c314 100644
--- a/server/middlewares/validators/videos/index.ts
+++ b/server/middlewares/validators/videos/index.ts
@@ -12,6 +12,8 @@ export * from './video-shares'
 export * from './video-source'
 export * from './video-stats'
 export * from './video-studio'
+export * from './video-token'
 export * from './video-transcoding'
 export * from './videos'
 export * from './video-channel-sync'
+export * from './video-passwords'
diff --git a/server/middlewares/validators/videos/video-captions.ts b/server/middlewares/validators/videos/video-captions.ts
index 72b2febc3..077a58d2e 100644
--- a/server/middlewares/validators/videos/video-captions.ts
+++ b/server/middlewares/validators/videos/video-captions.ts
@@ -10,7 +10,8 @@ import {
   checkUserCanManageVideo,
   doesVideoCaptionExist,
   doesVideoExist,
-  isValidVideoIdParam
+  isValidVideoIdParam,
+  isValidVideoPasswordHeader
 } from '../shared'
 
 const addVideoCaptionValidator = [
@@ -62,6 +63,8 @@ const deleteVideoCaptionValidator = [
 const listVideoCaptionsValidator = [
   isValidVideoIdParam('videoId'),
 
+  isValidVideoPasswordHeader(),
+
   async (req: express.Request, res: express.Response, next: express.NextFunction) => {
     if (areValidationErrors(req, res)) return
     if (!await doesVideoExist(req.params.videoId, res, 'only-video')) return
diff --git a/server/middlewares/validators/videos/video-comments.ts b/server/middlewares/validators/videos/video-comments.ts
index 133feb7bd..70689b02e 100644
--- a/server/middlewares/validators/videos/video-comments.ts
+++ b/server/middlewares/validators/videos/video-comments.ts
@@ -14,7 +14,8 @@ import {
   doesVideoCommentExist,
   doesVideoCommentThreadExist,
   doesVideoExist,
-  isValidVideoIdParam
+  isValidVideoIdParam,
+  isValidVideoPasswordHeader
 } from '../shared'
 
 const listVideoCommentsValidator = [
@@ -51,6 +52,7 @@ const listVideoCommentsValidator = [
 
 const listVideoCommentThreadsValidator = [
   isValidVideoIdParam('videoId'),
+  isValidVideoPasswordHeader(),
 
   async (req: express.Request, res: express.Response, next: express.NextFunction) => {
     if (areValidationErrors(req, res)) return
@@ -67,6 +69,7 @@ const listVideoThreadCommentsValidator = [
 
   param('threadId')
     .custom(isIdValid),
+  isValidVideoPasswordHeader(),
 
   async (req: express.Request, res: express.Response, next: express.NextFunction) => {
     if (areValidationErrors(req, res)) return
@@ -84,6 +87,7 @@ const addVideoCommentThreadValidator = [
 
   body('text')
     .custom(isValidVideoCommentText),
+  isValidVideoPasswordHeader(),
 
   async (req: express.Request, res: express.Response, next: express.NextFunction) => {
     if (areValidationErrors(req, res)) return
@@ -102,6 +106,7 @@ const addVideoCommentReplyValidator = [
   isValidVideoIdParam('videoId'),
 
   param('commentId').custom(isIdValid),
+  isValidVideoPasswordHeader(),
 
   body('text').custom(isValidVideoCommentText),
 
diff --git a/server/middlewares/validators/videos/video-files.ts b/server/middlewares/validators/videos/video-files.ts
index 92c5b9483..6c0ecda42 100644
--- a/server/middlewares/validators/videos/video-files.ts
+++ b/server/middlewares/validators/videos/video-files.ts
@@ -5,7 +5,7 @@ import { MVideo } from '@server/types/models'
 import { HttpStatusCode } from '@shared/models'
 import { areValidationErrors, doesVideoExist, isValidVideoIdParam } from '../shared'
 
-const videoFilesDeleteWebTorrentValidator = [
+const videoFilesDeleteWebVideoValidator = [
   isValidVideoIdParam('id'),
 
   async (req: express.Request, res: express.Response, next: express.NextFunction) => {
@@ -16,17 +16,17 @@ const videoFilesDeleteWebTorrentValidator = [
 
     if (!checkLocalVideo(video, res)) return
 
-    if (!video.hasWebTorrentFiles()) {
+    if (!video.hasWebVideoFiles()) {
       return res.fail({
         status: HttpStatusCode.BAD_REQUEST_400,
-        message: 'This video does not have WebTorrent files'
+        message: 'This video does not have Web Video files'
       })
     }
 
     if (!video.getHLSPlaylist()) {
       return res.fail({
         status: HttpStatusCode.BAD_REQUEST_400,
-        message: 'Cannot delete WebTorrent files since this video does not have HLS playlist'
+        message: 'Cannot delete Web Video files since this video does not have HLS playlist'
       })
     }
 
@@ -34,7 +34,7 @@ const videoFilesDeleteWebTorrentValidator = [
   }
 ]
 
-const videoFilesDeleteWebTorrentFileValidator = [
+const videoFilesDeleteWebVideoFileValidator = [
   isValidVideoIdParam('id'),
 
   param('videoFileId')
@@ -52,14 +52,14 @@ const videoFilesDeleteWebTorrentFileValidator = [
     if (!files.find(f => f.id === +req.params.videoFileId)) {
       return res.fail({
         status: HttpStatusCode.NOT_FOUND_404,
-        message: 'This video does not have this WebTorrent file id'
+        message: 'This video does not have this Web Video file id'
       })
     }
 
     if (files.length === 1 && !video.getHLSPlaylist()) {
       return res.fail({
         status: HttpStatusCode.BAD_REQUEST_400,
-        message: 'Cannot delete WebTorrent files since this video does not have HLS playlist'
+        message: 'Cannot delete Web Video files since this video does not have HLS playlist'
       })
     }
 
@@ -87,10 +87,10 @@ const videoFilesDeleteHLSValidator = [
       })
     }
 
-    if (!video.hasWebTorrentFiles()) {
+    if (!video.hasWebVideoFiles()) {
       return res.fail({
         status: HttpStatusCode.BAD_REQUEST_400,
-        message: 'Cannot delete HLS playlist since this video does not have WebTorrent files'
+        message: 'Cannot delete HLS playlist since this video does not have Web Video files'
       })
     }
 
@@ -128,10 +128,10 @@ const videoFilesDeleteHLSFileValidator = [
     }
 
     // Last file to delete
-    if (hlsFiles.length === 1 && !video.hasWebTorrentFiles()) {
+    if (hlsFiles.length === 1 && !video.hasWebVideoFiles()) {
       return res.fail({
         status: HttpStatusCode.BAD_REQUEST_400,
-        message: 'Cannot delete last HLS playlist file since this video does not have WebTorrent files'
+        message: 'Cannot delete last HLS playlist file since this video does not have Web Video files'
       })
     }
 
@@ -140,8 +140,8 @@ const videoFilesDeleteHLSFileValidator = [
 ]
 
 export {
-  videoFilesDeleteWebTorrentValidator,
-  videoFilesDeleteWebTorrentFileValidator,
+  videoFilesDeleteWebVideoValidator,
+  videoFilesDeleteWebVideoFileValidator,
 
   videoFilesDeleteHLSValidator,
   videoFilesDeleteHLSFileValidator
diff --git a/server/middlewares/validators/videos/video-imports.ts b/server/middlewares/validators/videos/video-imports.ts
index 72442aeb6..a1cb65b70 100644
--- a/server/middlewares/validators/videos/video-imports.ts
+++ b/server/middlewares/validators/videos/video-imports.ts
@@ -9,7 +9,11 @@ import { HttpStatusCode, UserRight, VideoImportState } from '@shared/models'
 import { VideoImportCreate } from '@shared/models/videos/import/video-import-create.model'
 import { isIdValid, toIntOrNull } from '../../../helpers/custom-validators/misc'
 import { isVideoImportTargetUrlValid, isVideoImportTorrentFile } from '../../../helpers/custom-validators/video-imports'
-import { isVideoMagnetUriValid, isVideoNameValid } from '../../../helpers/custom-validators/videos'
+import {
+  isValidPasswordProtectedPrivacy,
+  isVideoMagnetUriValid,
+  isVideoNameValid
+} from '../../../helpers/custom-validators/videos'
 import { cleanUpReqFiles } from '../../../helpers/express-utils'
 import { logger } from '../../../helpers/logger'
 import { CONFIG } from '../../../initializers/config'
@@ -38,6 +42,10 @@ const videoImportAddValidator = getCommonVideoEditAttributes().concat([
     .custom(isVideoNameValid).withMessage(
       `Should have a video name between ${CONSTRAINTS_FIELDS.VIDEOS.NAME.min} and ${CONSTRAINTS_FIELDS.VIDEOS.NAME.max} characters long`
     ),
+  body('videoPasswords')
+    .optional()
+    .isArray()
+    .withMessage('Video passwords should be an array.'),
 
   async (req: express.Request, res: express.Response, next: express.NextFunction) => {
     const user = res.locals.oauth.token.User
@@ -45,6 +53,8 @@ const videoImportAddValidator = getCommonVideoEditAttributes().concat([
 
     if (areValidationErrors(req, res)) return cleanUpReqFiles(req)
 
+    if (!isValidPasswordProtectedPrivacy(req, res)) return cleanUpReqFiles(req)
+
     if (CONFIG.IMPORT.VIDEOS.HTTP.ENABLED !== true && req.body.targetUrl) {
       cleanUpReqFiles(req)
 
diff --git a/server/middlewares/validators/videos/video-live.ts b/server/middlewares/validators/videos/video-live.ts
index 2aff831a8..ec69a3011 100644
--- a/server/middlewares/validators/videos/video-live.ts
+++ b/server/middlewares/validators/videos/video-live.ts
@@ -17,7 +17,7 @@ import {
   VideoState
 } from '@shared/models'
 import { exists, isBooleanValid, isIdValid, toBooleanOrNull, toIntOrNull } from '../../../helpers/custom-validators/misc'
-import { isVideoNameValid, isVideoPrivacyValid } from '../../../helpers/custom-validators/videos'
+import { isValidPasswordProtectedPrivacy, isVideoNameValid, isVideoReplayPrivacyValid } from '../../../helpers/custom-validators/videos'
 import { cleanUpReqFiles } from '../../../helpers/express-utils'
 import { logger } from '../../../helpers/logger'
 import { CONFIG } from '../../../initializers/config'
@@ -69,7 +69,7 @@ const videoLiveAddValidator = getCommonVideoEditAttributes().concat([
   body('replaySettings.privacy')
     .optional()
     .customSanitizer(toIntOrNull)
-    .custom(isVideoPrivacyValid),
+    .custom(isVideoReplayPrivacyValid),
 
   body('permanentLive')
     .optional()
@@ -81,9 +81,16 @@ const videoLiveAddValidator = getCommonVideoEditAttributes().concat([
     .customSanitizer(toIntOrNull)
     .custom(isLiveLatencyModeValid),
 
+  body('videoPasswords')
+    .optional()
+    .isArray()
+    .withMessage('Video passwords should be an array.'),
+
   async (req: express.Request, res: express.Response, next: express.NextFunction) => {
     if (areValidationErrors(req, res)) return cleanUpReqFiles(req)
 
+    if (!isValidPasswordProtectedPrivacy(req, res)) return cleanUpReqFiles(req)
+
     if (CONFIG.LIVE.ENABLED !== true) {
       cleanUpReqFiles(req)
 
@@ -170,7 +177,7 @@ const videoLiveUpdateValidator = [
   body('replaySettings.privacy')
     .optional()
     .customSanitizer(toIntOrNull)
-    .custom(isVideoPrivacyValid),
+    .custom(isVideoReplayPrivacyValid),
 
   body('latencyMode')
     .optional()
diff --git a/server/middlewares/validators/videos/video-passwords.ts b/server/middlewares/validators/videos/video-passwords.ts
new file mode 100644
index 000000000..200e496f6
--- /dev/null
+++ b/server/middlewares/validators/videos/video-passwords.ts
@@ -0,0 +1,77 @@
+import express from 'express'
+import {
+  areValidationErrors,
+  doesVideoExist,
+  isVideoPasswordProtected,
+  isValidVideoIdParam,
+  doesVideoPasswordExist,
+  isVideoPasswordDeletable,
+  checkUserCanManageVideo
+} from '../shared'
+import { body, param } from 'express-validator'
+import { isIdValid } from '@server/helpers/custom-validators/misc'
+import { isValidPasswordProtectedPrivacy } from '@server/helpers/custom-validators/videos'
+import { UserRight } from '@shared/models'
+
+const listVideoPasswordValidator = [
+  isValidVideoIdParam('videoId'),
+
+  async (req: express.Request, res: express.Response, next: express.NextFunction) => {
+    if (areValidationErrors(req, res)) return
+
+    if (!await doesVideoExist(req.params.videoId, res)) return
+    if (!isVideoPasswordProtected(res)) return
+
+    // Check if the user who did the request is able to access video password list
+    const user = res.locals.oauth.token.User
+    if (!checkUserCanManageVideo(user, res.locals.videoAll, UserRight.SEE_ALL_VIDEOS, res)) return
+
+    return next()
+  }
+]
+
+const updateVideoPasswordListValidator = [
+  body('passwords')
+    .optional()
+    .isArray()
+    .withMessage('Video passwords should be an array.'),
+
+  async (req: express.Request, res: express.Response, next: express.NextFunction) => {
+    if (areValidationErrors(req, res)) return
+
+    if (!await doesVideoExist(req.params.videoId, res)) return
+    if (!isValidPasswordProtectedPrivacy(req, res)) return
+
+    // Check if the user who did the request is able to update video passwords
+    const user = res.locals.oauth.token.User
+    if (!checkUserCanManageVideo(user, res.locals.videoAll, UserRight.UPDATE_ANY_VIDEO, res)) return
+
+    return next()
+  }
+]
+
+const removeVideoPasswordValidator = [
+  isValidVideoIdParam('videoId'),
+
+  param('passwordId')
+    .custom(isIdValid),
+
+  async (req: express.Request, res: express.Response, next: express.NextFunction) => {
+    if (areValidationErrors(req, res)) return
+
+    if (!await doesVideoExist(req.params.videoId, res)) return
+    if (!isVideoPasswordProtected(res)) return
+    if (!await doesVideoPasswordExist(req.params.passwordId, res)) return
+    if (!await isVideoPasswordDeletable(res)) return
+
+    return next()
+  }
+]
+
+// ---------------------------------------------------------------------------
+
+export {
+  listVideoPasswordValidator,
+  updateVideoPasswordListValidator,
+  removeVideoPasswordValidator
+}
diff --git a/server/middlewares/validators/videos/video-playlists.ts b/server/middlewares/validators/videos/video-playlists.ts
index c631a16f8..95a5ba63a 100644
--- a/server/middlewares/validators/videos/video-playlists.ts
+++ b/server/middlewares/validators/videos/video-playlists.ts
@@ -153,7 +153,7 @@ const videoPlaylistsGetValidator = (fetchType: VideoPlaylistFetchType) => {
       }
 
       if (videoPlaylist.privacy === VideoPlaylistPrivacy.PRIVATE) {
-        await authenticatePromise(req, res)
+        await authenticatePromise({ req, res })
 
         const user = res.locals.oauth ? res.locals.oauth.token.User : null
 
diff --git a/server/middlewares/validators/videos/video-rates.ts b/server/middlewares/validators/videos/video-rates.ts
index 275634d5b..c837b047b 100644
--- a/server/middlewares/validators/videos/video-rates.ts
+++ b/server/middlewares/validators/videos/video-rates.ts
@@ -7,13 +7,14 @@ import { isIdValid } from '../../../helpers/custom-validators/misc'
 import { isRatingValid } from '../../../helpers/custom-validators/video-rates'
 import { isVideoRatingTypeValid } from '../../../helpers/custom-validators/videos'
 import { AccountVideoRateModel } from '../../../models/account/account-video-rate'
-import { areValidationErrors, checkCanSeeVideo, doesVideoExist, isValidVideoIdParam } from '../shared'
+import { areValidationErrors, checkCanSeeVideo, doesVideoExist, isValidVideoIdParam, isValidVideoPasswordHeader } from '../shared'
 
 const videoUpdateRateValidator = [
   isValidVideoIdParam('id'),
 
   body('rating')
     .custom(isVideoRatingTypeValid),
+  isValidVideoPasswordHeader(),
 
   async (req: express.Request, res: express.Response, next: express.NextFunction) => {
     if (areValidationErrors(req, res)) return
diff --git a/server/middlewares/validators/videos/video-token.ts b/server/middlewares/validators/videos/video-token.ts
new file mode 100644
index 000000000..d4253e21d
--- /dev/null
+++ b/server/middlewares/validators/videos/video-token.ts
@@ -0,0 +1,24 @@
+import express from 'express'
+import { VideoPrivacy } from '../../../../shared/models/videos'
+import { HttpStatusCode } from '@shared/models'
+import { exists } from '@server/helpers/custom-validators/misc'
+
+const videoFileTokenValidator = [
+  (req: express.Request, res: express.Response, next: express.NextFunction) => {
+    const video = res.locals.onlyVideo
+    if (video.privacy !== VideoPrivacy.PASSWORD_PROTECTED && !exists(res.locals.oauth.token.User)) {
+      return res.fail({
+        status: HttpStatusCode.UNAUTHORIZED_401,
+        message: 'Not authenticated'
+      })
+    }
+
+    return next()
+  }
+]
+
+// ---------------------------------------------------------------------------
+
+export {
+  videoFileTokenValidator
+}
diff --git a/server/middlewares/validators/videos/videos.ts b/server/middlewares/validators/videos/videos.ts
index 794e1d4f1..b39d13a23 100644
--- a/server/middlewares/validators/videos/videos.ts
+++ b/server/middlewares/validators/videos/videos.ts
@@ -2,6 +2,7 @@ import express from 'express'
 import { body, header, param, query, ValidationChain } from 'express-validator'
 import { isTestInstance } from '@server/helpers/core-utils'
 import { getResumableUploadPath } from '@server/helpers/upload'
+import { uploadx } from '@server/lib/uploadx'
 import { Redis } from '@server/lib/redis'
 import { getServerActor } from '@server/models/application/application'
 import { ExpressPromiseHandler } from '@server/types/express-handler'
@@ -23,6 +24,7 @@ import { isBooleanBothQueryValid, isNumberArray, isStringArray } from '../../../
 import {
   areVideoTagsValid,
   isScheduleVideoUpdatePrivacyValid,
+  isValidPasswordProtectedPrivacy,
   isVideoCategoryValid,
   isVideoDescriptionValid,
   isVideoFileMimeTypeValid,
@@ -39,7 +41,6 @@ import {
 } from '../../../helpers/custom-validators/videos'
 import { cleanUpReqFiles } from '../../../helpers/express-utils'
 import { logger } from '../../../helpers/logger'
-import { deleteFileAndCatch } from '../../../helpers/utils'
 import { getVideoWithAttributes } from '../../../helpers/video'
 import { CONFIG } from '../../../initializers/config'
 import { CONSTRAINTS_FIELDS, OVERVIEWS } from '../../../initializers/constants'
@@ -55,7 +56,8 @@ import {
   doesVideoChannelOfAccountExist,
   doesVideoExist,
   doesVideoFileOfVideoExist,
-  isValidVideoIdParam
+  isValidVideoIdParam,
+  isValidVideoPasswordHeader
 } from '../shared'
 
 const videosAddLegacyValidator = getCommonVideoEditAttributes().concat([
@@ -70,6 +72,10 @@ const videosAddLegacyValidator = getCommonVideoEditAttributes().concat([
   body('channelId')
     .customSanitizer(toIntOrNull)
     .custom(isIdValid),
+  body('videoPasswords')
+    .optional()
+    .isArray()
+    .withMessage('Video passwords should be an array.'),
 
   async (req: express.Request, res: express.Response, next: express.NextFunction) => {
     if (areValidationErrors(req, res)) return cleanUpReqFiles(req)
@@ -81,6 +87,8 @@ const videosAddLegacyValidator = getCommonVideoEditAttributes().concat([
       return cleanUpReqFiles(req)
     }
 
+    if (!isValidPasswordProtectedPrivacy(req, res)) return cleanUpReqFiles(req)
+
     try {
       if (!videoFile.duration) await addDurationToVideo(videoFile)
     } catch (err) {
@@ -107,7 +115,7 @@ const videosAddResumableValidator = [
     const user = res.locals.oauth.token.User
     const body: express.CustomUploadXFile<express.UploadXFileMetadata> = req.body
     const file = { ...body, duration: undefined, path: getResumableUploadPath(body.name), filename: body.metadata.filename }
-    const cleanup = () => deleteFileAndCatch(file.path)
+    const cleanup = () => uploadx.storage.delete(file).catch(err => logger.error('Cannot delete the file %s', file.name, { err }))
 
     const uploadId = req.query.upload_id
     const sessionExists = await Redis.Instance.doesUploadSessionExist(uploadId)
@@ -124,11 +132,15 @@ const videosAddResumableValidator = [
         })
       }
 
-      if (isTestInstance()) {
-        res.setHeader('x-resumable-upload-cached', 'true')
-      }
+      const videoStillExists = await VideoModel.load(sessionResponse.video.id)
+
+      if (videoStillExists) {
+        if (isTestInstance()) {
+          res.setHeader('x-resumable-upload-cached', 'true')
+        }
 
-      return res.json(sessionResponse)
+        return res.json(sessionResponse)
+      }
     }
 
     await Redis.Instance.setUploadSession(uploadId)
@@ -174,6 +186,10 @@ const videosAddResumableInitValidator = getCommonVideoEditAttributes().concat([
   body('channelId')
     .customSanitizer(toIntOrNull)
     .custom(isIdValid),
+  body('videoPasswords')
+    .optional()
+    .isArray()
+    .withMessage('Video passwords should be an array.'),
 
   header('x-upload-content-length')
     .isNumeric()
@@ -205,10 +221,14 @@ const videosAddResumableInitValidator = getCommonVideoEditAttributes().concat([
     const files = { videofile: [ videoFileMetadata ] }
     if (!await commonVideoChecksPass({ req, res, user, videoFileSize: videoFileMetadata.size, files })) return cleanup()
 
-    // multer required unsetting the Content-Type, now we can set it for node-uploadx
+    if (!isValidPasswordProtectedPrivacy(req, res)) return cleanup()
+
+    // Multer required unsetting the Content-Type, now we can set it for node-uploadx
     req.headers['content-type'] = 'application/json; charset=utf-8'
-    // place previewfile in metadata so that uploadx saves it in .META
+
+    // Place thumbnail/previewfile in metadata so that uploadx saves it in .META
     if (req.files?.['previewfile']) req.body.previewfile = req.files['previewfile']
+    if (req.files?.['thumbnailfile']) req.body.thumbnailfile = req.files['thumbnailfile']
 
     return next()
   }
@@ -227,12 +247,18 @@ const videosUpdateValidator = getCommonVideoEditAttributes().concat([
     .optional()
     .customSanitizer(toIntOrNull)
     .custom(isIdValid),
+  body('videoPasswords')
+    .optional()
+    .isArray()
+    .withMessage('Video passwords should be an array.'),
 
   async (req: express.Request, res: express.Response, next: express.NextFunction) => {
     if (areValidationErrors(req, res)) return cleanUpReqFiles(req)
     if (areErrorsInScheduleUpdate(req, res)) return cleanUpReqFiles(req)
     if (!await doesVideoExist(req.params.id, res)) return cleanUpReqFiles(req)
 
+    if (!isValidPasswordProtectedPrivacy(req, res)) return cleanUpReqFiles(req)
+
     const video = getVideoWithAttributes(res)
     if (video.isLive && video.privacy !== req.body.privacy && video.state !== VideoState.WAITING_FOR_LIVE) {
       return res.fail({ message: 'Cannot update privacy of a live that has already started' })
@@ -281,6 +307,8 @@ const videosCustomGetValidator = (fetchType: 'for-api' | 'all' | 'only-video' |
   return [
     isValidVideoIdParam('id'),
 
+    isValidVideoPasswordHeader(),
+
     async (req: express.Request, res: express.Response, next: express.NextFunction) => {
       if (areValidationErrors(req, res)) return
       if (!await doesVideoExist(req.params.id, res, fetchType)) return
@@ -478,10 +506,14 @@ const commonVideosFiltersValidator = [
     .optional()
     .customSanitizer(toBooleanOrNull)
     .custom(isBooleanValid).withMessage('Should have a valid hasHLSFiles boolean'),
-  query('hasWebtorrentFiles')
+  query('hasWebtorrentFiles') // TODO: remove in v7
     .optional()
     .customSanitizer(toBooleanOrNull)
     .custom(isBooleanValid).withMessage('Should have a valid hasWebtorrentFiles boolean'),
+  query('hasWebVideoFiles')
+    .optional()
+    .customSanitizer(toBooleanOrNull)
+    .custom(isBooleanValid).withMessage('Should have a valid hasWebVideoFiles boolean'),
   query('skipCount')
     .optional()
     .customSanitizer(toBooleanOrNull)
diff --git a/server/models/actor/actor-image.ts b/server/models/actor/actor-image.ts
index 9c34a0101..51085a16d 100644
--- a/server/models/actor/actor-image.ts
+++ b/server/models/actor/actor-image.ts
@@ -157,11 +157,11 @@ export class ActorImageModel extends Model<Partial<AttributesOnly<ActorImageMode
   }
 
   getPath () {
-    return join(CONFIG.STORAGE.ACTOR_IMAGES, this.filename)
+    return join(CONFIG.STORAGE.ACTOR_IMAGES_DIR, this.filename)
   }
 
   removeImage () {
-    const imagePath = join(CONFIG.STORAGE.ACTOR_IMAGES, this.filename)
+    const imagePath = join(CONFIG.STORAGE.ACTOR_IMAGES_DIR, this.filename)
     return remove(imagePath)
   }
 
diff --git a/server/models/redundancy/video-redundancy.ts b/server/models/redundancy/video-redundancy.ts
index c2a72b71f..cebf47dfd 100644
--- a/server/models/redundancy/video-redundancy.ts
+++ b/server/models/redundancy/video-redundancy.ts
@@ -162,7 +162,7 @@ export class VideoRedundancyModel extends Model<Partial<AttributesOnly<VideoRedu
       const logIdentifier = `${videoFile.Video.uuid}-${videoFile.resolution}`
       logger.info('Removing duplicated video file %s.', logIdentifier)
 
-      videoFile.Video.removeWebTorrentFile(videoFile, true)
+      videoFile.Video.removeWebVideoFile(videoFile, true)
         .catch(err => logger.error('Cannot delete %s files.', logIdentifier, { err }))
     }
 
diff --git a/server/models/user/user.ts b/server/models/user/user.ts
index 4f6a8fce4..ff6328d48 100644
--- a/server/models/user/user.ts
+++ b/server/models/user/user.ts
@@ -786,7 +786,7 @@ export class UserModel extends Model<Partial<AttributesOnly<UserModel>>> {
       'INNER JOIN "account" ON "videoChannel"."accountId" = "account"."id" ' +
       `WHERE "account"."userId" = ${options.whereUserId} ${andWhere}`
 
-    const webtorrentFiles = 'SELECT "videoFile"."size" AS "size", "video"."id" AS "videoId" FROM "videoFile" ' +
+    const webVideoFiles = 'SELECT "videoFile"."size" AS "size", "video"."id" AS "videoId" FROM "videoFile" ' +
       'INNER JOIN "video" ON "videoFile"."videoId" = "video"."id" AND "video"."isLive" IS FALSE ' +
       videoChannelJoin
 
@@ -797,7 +797,7 @@ export class UserModel extends Model<Partial<AttributesOnly<UserModel>>> {
 
     return 'SELECT COALESCE(SUM("size"), 0) AS "total" ' +
       'FROM (' +
-        `SELECT MAX("t1"."size") AS "size" FROM (${webtorrentFiles} UNION ${hlsFiles}) t1 ` +
+        `SELECT MAX("t1"."size") AS "size" FROM (${webVideoFiles} UNION ${hlsFiles}) t1 ` +
         'GROUP BY "t1"."videoId"' +
       ') t2'
   }
@@ -890,8 +890,6 @@ export class UserModel extends Model<Partial<AttributesOnly<UserModel>>> {
 
       nsfwPolicy: this.nsfwPolicy,
 
-      // FIXME: deprecated in 4.1
-      webTorrentEnabled: this.p2pEnabled,
       p2pEnabled: this.p2pEnabled,
 
       videosHistoryEnabled: this.videosHistoryEnabled,
diff --git a/server/models/video/formatter/index.ts b/server/models/video/formatter/index.ts
new file mode 100644
index 000000000..77b406559
--- /dev/null
+++ b/server/models/video/formatter/index.ts
@@ -0,0 +1,2 @@
+export * from './video-activity-pub-format'
+export * from './video-api-format'
diff --git a/server/models/video/formatter/shared/index.ts b/server/models/video/formatter/shared/index.ts
new file mode 100644
index 000000000..d558fa7d6
--- /dev/null
+++ b/server/models/video/formatter/shared/index.ts
@@ -0,0 +1 @@
+export * from './video-format-utils'
diff --git a/server/models/video/formatter/shared/video-format-utils.ts b/server/models/video/formatter/shared/video-format-utils.ts
new file mode 100644
index 000000000..df3bbdf1c
--- /dev/null
+++ b/server/models/video/formatter/shared/video-format-utils.ts
@@ -0,0 +1,7 @@
+import { MVideoFile } from '@server/types/models'
+
+export function sortByResolutionDesc (fileA: MVideoFile, fileB: MVideoFile) {
+  if (fileA.resolution < fileB.resolution) return 1
+  if (fileA.resolution === fileB.resolution) return 0
+  return -1
+}
diff --git a/server/models/video/formatter/video-activity-pub-format.ts b/server/models/video/formatter/video-activity-pub-format.ts
new file mode 100644
index 000000000..c0d3d5f3e
--- /dev/null
+++ b/server/models/video/formatter/video-activity-pub-format.ts
@@ -0,0 +1,295 @@
+
+import { isArray } from 'lodash'
+import { generateMagnetUri } from '@server/helpers/webtorrent'
+import { getActivityStreamDuration } from '@server/lib/activitypub/activity'
+import { getLocalVideoFileMetadataUrl } from '@server/lib/video-urls'
+import {
+  ActivityIconObject,
+  ActivityPlaylistUrlObject,
+  ActivityPubStoryboard,
+  ActivityTagObject,
+  ActivityTrackerUrlObject,
+  ActivityUrlObject,
+  VideoObject
+} from '@shared/models'
+import { MIMETYPES, WEBSERVER } from '../../../initializers/constants'
+import {
+  getLocalVideoCommentsActivityPubUrl,
+  getLocalVideoDislikesActivityPubUrl,
+  getLocalVideoLikesActivityPubUrl,
+  getLocalVideoSharesActivityPubUrl
+} from '../../../lib/activitypub/url'
+import { MStreamingPlaylistFiles, MUserId, MVideo, MVideoAP, MVideoFile } from '../../../types/models'
+import { VideoCaptionModel } from '../video-caption'
+import { sortByResolutionDesc } from './shared'
+import { getCategoryLabel, getLanguageLabel, getLicenceLabel } from './video-api-format'
+
+export function videoModelToActivityPubObject (video: MVideoAP): VideoObject {
+  const language = video.language
+    ? { identifier: video.language, name: getLanguageLabel(video.language) }
+    : undefined
+
+  const category = video.category
+    ? { identifier: video.category + '', name: getCategoryLabel(video.category) }
+    : undefined
+
+  const licence = video.licence
+    ? { identifier: video.licence + '', name: getLicenceLabel(video.licence) }
+    : undefined
+
+  const url: ActivityUrlObject[] = [
+    // HTML url should be the first element in the array so Mastodon correctly displays the embed
+    {
+      type: 'Link',
+      mediaType: 'text/html',
+      href: WEBSERVER.URL + '/videos/watch/' + video.uuid
+    } as ActivityUrlObject,
+
+    ...buildVideoFileUrls({ video, files: video.VideoFiles }),
+
+    ...buildStreamingPlaylistUrls(video),
+
+    ...buildTrackerUrls(video)
+  ]
+
+  return {
+    type: 'Video' as 'Video',
+    id: video.url,
+    name: video.name,
+    duration: getActivityStreamDuration(video.duration),
+    uuid: video.uuid,
+    category,
+    licence,
+    language,
+    views: video.views,
+    sensitive: video.nsfw,
+    waitTranscoding: video.waitTranscoding,
+
+    state: video.state,
+    commentsEnabled: video.commentsEnabled,
+    downloadEnabled: video.downloadEnabled,
+    published: video.publishedAt.toISOString(),
+
+    originallyPublishedAt: video.originallyPublishedAt
+      ? video.originallyPublishedAt.toISOString()
+      : null,
+
+    updated: video.updatedAt.toISOString(),
+
+    tag: buildTags(video),
+
+    mediaType: 'text/markdown',
+    content: video.description,
+    support: video.support,
+
+    subtitleLanguage: buildSubtitleLanguage(video),
+
+    icon: buildIcon(video),
+
+    preview: buildPreviewAPAttribute(video),
+
+    url,
+
+    likes: getLocalVideoLikesActivityPubUrl(video),
+    dislikes: getLocalVideoDislikesActivityPubUrl(video),
+    shares: getLocalVideoSharesActivityPubUrl(video),
+    comments: getLocalVideoCommentsActivityPubUrl(video),
+
+    attributedTo: [
+      {
+        type: 'Person',
+        id: video.VideoChannel.Account.Actor.url
+      },
+      {
+        type: 'Group',
+        id: video.VideoChannel.Actor.url
+      }
+    ],
+
+    ...buildLiveAPAttributes(video)
+  }
+}
+
+// ---------------------------------------------------------------------------
+// Private
+// ---------------------------------------------------------------------------
+
+function buildLiveAPAttributes (video: MVideoAP) {
+  if (!video.isLive) {
+    return {
+      isLiveBroadcast: false,
+      liveSaveReplay: null,
+      permanentLive: null,
+      latencyMode: null
+    }
+  }
+
+  return {
+    isLiveBroadcast: true,
+    liveSaveReplay: video.VideoLive.saveReplay,
+    permanentLive: video.VideoLive.permanentLive,
+    latencyMode: video.VideoLive.latencyMode
+  }
+}
+
+function buildPreviewAPAttribute (video: MVideoAP): ActivityPubStoryboard[] {
+  if (!video.Storyboard) return undefined
+
+  const storyboard = video.Storyboard
+
+  return [
+    {
+      type: 'Image',
+      rel: [ 'storyboard' ],
+      url: [
+        {
+          mediaType: 'image/jpeg',
+
+          href: storyboard.getOriginFileUrl(video),
+
+          width: storyboard.totalWidth,
+          height: storyboard.totalHeight,
+
+          tileWidth: storyboard.spriteWidth,
+          tileHeight: storyboard.spriteHeight,
+          tileDuration: getActivityStreamDuration(storyboard.spriteDuration)
+        }
+      ]
+    }
+  ]
+}
+
+function buildVideoFileUrls (options: {
+  video: MVideo
+  files: MVideoFile[]
+  user?: MUserId
+}): ActivityUrlObject[] {
+  const { video, files } = options
+
+  if (!isArray(files)) return []
+
+  const urls: ActivityUrlObject[] = []
+
+  const trackerUrls = video.getTrackerUrls()
+  const sortedFiles = files
+    .filter(f => !f.isLive())
+    .sort(sortByResolutionDesc)
+
+  for (const file of sortedFiles) {
+    urls.push({
+      type: 'Link',
+      mediaType: MIMETYPES.VIDEO.EXT_MIMETYPE[file.extname] as any,
+      href: file.getFileUrl(video),
+      height: file.resolution,
+      size: file.size,
+      fps: file.fps
+    })
+
+    urls.push({
+      type: 'Link',
+      rel: [ 'metadata', MIMETYPES.VIDEO.EXT_MIMETYPE[file.extname] ],
+      mediaType: 'application/json' as 'application/json',
+      href: getLocalVideoFileMetadataUrl(video, file),
+      height: file.resolution,
+      fps: file.fps
+    })
+
+    if (file.hasTorrent()) {
+      urls.push({
+        type: 'Link',
+        mediaType: 'application/x-bittorrent' as 'application/x-bittorrent',
+        href: file.getTorrentUrl(),
+        height: file.resolution
+      })
+
+      urls.push({
+        type: 'Link',
+        mediaType: 'application/x-bittorrent;x-scheme-handler/magnet' as 'application/x-bittorrent;x-scheme-handler/magnet',
+        href: generateMagnetUri(video, file, trackerUrls),
+        height: file.resolution
+      })
+    }
+  }
+
+  return urls
+}
+
+// ---------------------------------------------------------------------------
+
+function buildStreamingPlaylistUrls (video: MVideoAP): ActivityPlaylistUrlObject[] {
+  if (!isArray(video.VideoStreamingPlaylists)) return []
+
+  return video.VideoStreamingPlaylists
+    .map(playlist => ({
+      type: 'Link',
+      mediaType: 'application/x-mpegURL' as 'application/x-mpegURL',
+      href: playlist.getMasterPlaylistUrl(video),
+      tag: buildStreamingPlaylistTags(video, playlist)
+    }))
+}
+
+function buildStreamingPlaylistTags (video: MVideoAP, playlist: MStreamingPlaylistFiles) {
+  return [
+    ...playlist.p2pMediaLoaderInfohashes.map(i => ({ type: 'Infohash' as 'Infohash', name: i })),
+
+    {
+      type: 'Link',
+      name: 'sha256',
+      mediaType: 'application/json' as 'application/json',
+      href: playlist.getSha256SegmentsUrl(video)
+    },
+
+    ...buildVideoFileUrls({ video, files: playlist.VideoFiles })
+  ] as ActivityTagObject[]
+}
+
+// ---------------------------------------------------------------------------
+
+function buildTrackerUrls (video: MVideoAP): ActivityTrackerUrlObject[] {
+  return video.getTrackerUrls()
+    .map(trackerUrl => {
+      const rel2 = trackerUrl.startsWith('http')
+        ? 'http'
+        : 'websocket'
+
+      return {
+        type: 'Link',
+        name: `tracker-${rel2}`,
+        rel: [ 'tracker', rel2 ],
+        href: trackerUrl
+      }
+    })
+}
+
+// ---------------------------------------------------------------------------
+
+function buildTags (video: MVideoAP) {
+  if (!isArray(video.Tags)) return []
+
+  return video.Tags.map(t => ({
+    type: 'Hashtag' as 'Hashtag',
+    name: t.name
+  }))
+}
+
+function buildIcon (video: MVideoAP): ActivityIconObject[] {
+  return [ video.getMiniature(), video.getPreview() ]
+    .map(i => ({
+      type: 'Image',
+      url: i.getOriginFileUrl(video),
+      mediaType: 'image/jpeg',
+      width: i.width,
+      height: i.height
+    }))
+}
+
+function buildSubtitleLanguage (video: MVideoAP) {
+  if (!isArray(video.VideoCaptions)) return []
+
+  return video.VideoCaptions
+    .map(caption => ({
+      identifier: caption.language,
+      name: VideoCaptionModel.getLanguageLabel(caption.language),
+      url: caption.getFileUrl(video)
+    }))
+}
diff --git a/server/models/video/formatter/video-api-format.ts b/server/models/video/formatter/video-api-format.ts
new file mode 100644
index 000000000..1af51d132
--- /dev/null
+++ b/server/models/video/formatter/video-api-format.ts
@@ -0,0 +1,304 @@
+import { generateMagnetUri } from '@server/helpers/webtorrent'
+import { tracer } from '@server/lib/opentelemetry/tracing'
+import { getLocalVideoFileMetadataUrl } from '@server/lib/video-urls'
+import { VideoViewsManager } from '@server/lib/views/video-views-manager'
+import { uuidToShort } from '@shared/extra-utils'
+import {
+  Video,
+  VideoAdditionalAttributes,
+  VideoDetails,
+  VideoFile,
+  VideoInclude,
+  VideosCommonQueryAfterSanitize,
+  VideoStreamingPlaylist
+} from '@shared/models'
+import { isArray } from '../../../helpers/custom-validators/misc'
+import { VIDEO_CATEGORIES, VIDEO_LANGUAGES, VIDEO_LICENCES, VIDEO_PRIVACIES, VIDEO_STATES } from '../../../initializers/constants'
+import { MServer, MStreamingPlaylistRedundanciesOpt, MVideoFormattable, MVideoFormattableDetails } from '../../../types/models'
+import { MVideoFileRedundanciesOpt } from '../../../types/models/video/video-file'
+import { sortByResolutionDesc } from './shared'
+
+export type VideoFormattingJSONOptions = {
+  completeDescription?: boolean
+
+  additionalAttributes?: {
+    state?: boolean
+    waitTranscoding?: boolean
+    scheduledUpdate?: boolean
+    blacklistInfo?: boolean
+    files?: boolean
+    blockedOwner?: boolean
+  }
+}
+
+export function guessAdditionalAttributesFromQuery (query: VideosCommonQueryAfterSanitize): VideoFormattingJSONOptions {
+  if (!query?.include) return {}
+
+  return {
+    additionalAttributes: {
+      state: !!(query.include & VideoInclude.NOT_PUBLISHED_STATE),
+      waitTranscoding: !!(query.include & VideoInclude.NOT_PUBLISHED_STATE),
+      scheduledUpdate: !!(query.include & VideoInclude.NOT_PUBLISHED_STATE),
+      blacklistInfo: !!(query.include & VideoInclude.BLACKLISTED),
+      files: !!(query.include & VideoInclude.FILES),
+      blockedOwner: !!(query.include & VideoInclude.BLOCKED_OWNER)
+    }
+  }
+}
+
+// ---------------------------------------------------------------------------
+
+export function videoModelToFormattedJSON (video: MVideoFormattable, options: VideoFormattingJSONOptions = {}): Video {
+  const span = tracer.startSpan('peertube.VideoModel.toFormattedJSON')
+
+  const userHistory = isArray(video.UserVideoHistories)
+    ? video.UserVideoHistories[0]
+    : undefined
+
+  const videoObject: Video = {
+    id: video.id,
+    uuid: video.uuid,
+    shortUUID: uuidToShort(video.uuid),
+
+    url: video.url,
+
+    name: video.name,
+    category: {
+      id: video.category,
+      label: getCategoryLabel(video.category)
+    },
+    licence: {
+      id: video.licence,
+      label: getLicenceLabel(video.licence)
+    },
+    language: {
+      id: video.language,
+      label: getLanguageLabel(video.language)
+    },
+    privacy: {
+      id: video.privacy,
+      label: getPrivacyLabel(video.privacy)
+    },
+    nsfw: video.nsfw,
+
+    truncatedDescription: video.getTruncatedDescription(),
+    description: options && options.completeDescription === true
+      ? video.description
+      : video.getTruncatedDescription(),
+
+    isLocal: video.isOwned(),
+    duration: video.duration,
+
+    views: video.views,
+    viewers: VideoViewsManager.Instance.getViewers(video),
+
+    likes: video.likes,
+    dislikes: video.dislikes,
+    thumbnailPath: video.getMiniatureStaticPath(),
+    previewPath: video.getPreviewStaticPath(),
+    embedPath: video.getEmbedStaticPath(),
+    createdAt: video.createdAt,
+    updatedAt: video.updatedAt,
+    publishedAt: video.publishedAt,
+    originallyPublishedAt: video.originallyPublishedAt,
+
+    isLive: video.isLive,
+
+    account: video.VideoChannel.Account.toFormattedSummaryJSON(),
+    channel: video.VideoChannel.toFormattedSummaryJSON(),
+
+    userHistory: userHistory
+      ? { currentTime: userHistory.currentTime }
+      : undefined,
+
+    // Can be added by external plugins
+    pluginData: (video as any).pluginData,
+
+    ...buildAdditionalAttributes(video, options)
+  }
+
+  span.end()
+
+  return videoObject
+}
+
+export function videoModelToFormattedDetailsJSON (video: MVideoFormattableDetails): VideoDetails {
+  const span = tracer.startSpan('peertube.VideoModel.toFormattedDetailsJSON')
+
+  const videoJSON = video.toFormattedJSON({
+    completeDescription: true,
+    additionalAttributes: {
+      scheduledUpdate: true,
+      blacklistInfo: true,
+      files: true
+    }
+  }) as Video & Required<Pick<Video, 'files' | 'streamingPlaylists' | 'scheduledUpdate' | 'blacklisted' | 'blacklistedReason'>>
+
+  const tags = video.Tags
+    ? video.Tags.map(t => t.name)
+    : []
+
+  const detailsJSON = {
+    ...videoJSON,
+
+    support: video.support,
+    descriptionPath: video.getDescriptionAPIPath(),
+    channel: video.VideoChannel.toFormattedJSON(),
+    account: video.VideoChannel.Account.toFormattedJSON(),
+    tags,
+    commentsEnabled: video.commentsEnabled,
+    downloadEnabled: video.downloadEnabled,
+    waitTranscoding: video.waitTranscoding,
+    state: {
+      id: video.state,
+      label: getStateLabel(video.state)
+    },
+
+    trackerUrls: video.getTrackerUrls()
+  }
+
+  span.end()
+
+  return detailsJSON
+}
+
+export function streamingPlaylistsModelToFormattedJSON (
+  video: MVideoFormattable,
+  playlists: MStreamingPlaylistRedundanciesOpt[]
+): VideoStreamingPlaylist[] {
+  if (isArray(playlists) === false) return []
+
+  return playlists
+    .map(playlist => ({
+      id: playlist.id,
+      type: playlist.type,
+
+      playlistUrl: playlist.getMasterPlaylistUrl(video),
+      segmentsSha256Url: playlist.getSha256SegmentsUrl(video),
+
+      redundancies: isArray(playlist.RedundancyVideos)
+        ? playlist.RedundancyVideos.map(r => ({ baseUrl: r.fileUrl }))
+        : [],
+
+      files: videoFilesModelToFormattedJSON(video, playlist.VideoFiles)
+    }))
+}
+
+export function videoFilesModelToFormattedJSON (
+  video: MVideoFormattable,
+  videoFiles: MVideoFileRedundanciesOpt[],
+  options: {
+    includeMagnet?: boolean // default true
+  } = {}
+): VideoFile[] {
+  const { includeMagnet = true } = options
+
+  if (isArray(videoFiles) === false) return []
+
+  const trackerUrls = includeMagnet
+    ? video.getTrackerUrls()
+    : []
+
+  return videoFiles
+    .filter(f => !f.isLive())
+    .sort(sortByResolutionDesc)
+    .map(videoFile => {
+      return {
+        id: videoFile.id,
+
+        resolution: {
+          id: videoFile.resolution,
+          label: videoFile.resolution === 0
+            ? 'Audio'
+            : `${videoFile.resolution}p`
+        },
+
+        magnetUri: includeMagnet && videoFile.hasTorrent()
+          ? generateMagnetUri(video, videoFile, trackerUrls)
+          : undefined,
+
+        size: videoFile.size,
+        fps: videoFile.fps,
+
+        torrentUrl: videoFile.getTorrentUrl(),
+        torrentDownloadUrl: videoFile.getTorrentDownloadUrl(),
+
+        fileUrl: videoFile.getFileUrl(video),
+        fileDownloadUrl: videoFile.getFileDownloadUrl(video),
+
+        metadataUrl: videoFile.metadataUrl ?? getLocalVideoFileMetadataUrl(video, videoFile)
+      }
+    })
+}
+
+// ---------------------------------------------------------------------------
+
+export function getCategoryLabel (id: number) {
+  return VIDEO_CATEGORIES[id] || 'Unknown'
+}
+
+export function getLicenceLabel (id: number) {
+  return VIDEO_LICENCES[id] || 'Unknown'
+}
+
+export function getLanguageLabel (id: string) {
+  return VIDEO_LANGUAGES[id] || 'Unknown'
+}
+
+export function getPrivacyLabel (id: number) {
+  return VIDEO_PRIVACIES[id] || 'Unknown'
+}
+
+export function getStateLabel (id: number) {
+  return VIDEO_STATES[id] || 'Unknown'
+}
+
+// ---------------------------------------------------------------------------
+// Private
+// ---------------------------------------------------------------------------
+
+function buildAdditionalAttributes (video: MVideoFormattable, options: VideoFormattingJSONOptions) {
+  const add = options.additionalAttributes
+
+  const result: Partial<VideoAdditionalAttributes> = {}
+
+  if (add?.state === true) {
+    result.state = {
+      id: video.state,
+      label: getStateLabel(video.state)
+    }
+  }
+
+  if (add?.waitTranscoding === true) {
+    result.waitTranscoding = video.waitTranscoding
+  }
+
+  if (add?.scheduledUpdate === true && video.ScheduleVideoUpdate) {
+    result.scheduledUpdate = {
+      updateAt: video.ScheduleVideoUpdate.updateAt,
+      privacy: video.ScheduleVideoUpdate.privacy || undefined
+    }
+  }
+
+  if (add?.blacklistInfo === true) {
+    result.blacklisted = !!video.VideoBlacklist
+    result.blacklistedReason =
+      video.VideoBlacklist
+        ? video.VideoBlacklist.reason
+        : null
+  }
+
+  if (add?.blockedOwner === true) {
+    result.blockedOwner = video.VideoChannel.Account.isBlocked()
+
+    const server = video.VideoChannel.Account.Actor.Server as MServer
+    result.blockedServer = !!(server?.isBlocked())
+  }
+
+  if (add?.files === true) {
+    result.streamingPlaylists = streamingPlaylistsModelToFormattedJSON(video, video.VideoStreamingPlaylists)
+    result.files = videoFilesModelToFormattedJSON(video, video.VideoFiles)
+  }
+
+  return result
+}
diff --git a/server/models/video/formatter/video-format-utils.ts b/server/models/video/formatter/video-format-utils.ts
deleted file mode 100644
index f2001e432..000000000
--- a/server/models/video/formatter/video-format-utils.ts
+++ /dev/null
@@ -1,543 +0,0 @@
-import { generateMagnetUri } from '@server/helpers/webtorrent'
-import { getActivityStreamDuration } from '@server/lib/activitypub/activity'
-import { tracer } from '@server/lib/opentelemetry/tracing'
-import { getLocalVideoFileMetadataUrl } from '@server/lib/video-urls'
-import { VideoViewsManager } from '@server/lib/views/video-views-manager'
-import { uuidToShort } from '@shared/extra-utils'
-import {
-  ActivityTagObject,
-  ActivityUrlObject,
-  Video,
-  VideoDetails,
-  VideoFile,
-  VideoInclude,
-  VideoObject,
-  VideosCommonQueryAfterSanitize,
-  VideoStreamingPlaylist
-} from '@shared/models'
-import { isArray } from '../../../helpers/custom-validators/misc'
-import {
-  MIMETYPES,
-  VIDEO_CATEGORIES,
-  VIDEO_LANGUAGES,
-  VIDEO_LICENCES,
-  VIDEO_PRIVACIES,
-  VIDEO_STATES,
-  WEBSERVER
-} from '../../../initializers/constants'
-import {
-  getLocalVideoCommentsActivityPubUrl,
-  getLocalVideoDislikesActivityPubUrl,
-  getLocalVideoLikesActivityPubUrl,
-  getLocalVideoSharesActivityPubUrl
-} from '../../../lib/activitypub/url'
-import {
-  MServer,
-  MStreamingPlaylistRedundanciesOpt,
-  MUserId,
-  MVideo,
-  MVideoAP,
-  MVideoFile,
-  MVideoFormattable,
-  MVideoFormattableDetails
-} from '../../../types/models'
-import { MVideoFileRedundanciesOpt } from '../../../types/models/video/video-file'
-import { VideoCaptionModel } from '../video-caption'
-
-export type VideoFormattingJSONOptions = {
-  completeDescription?: boolean
-
-  additionalAttributes?: {
-    state?: boolean
-    waitTranscoding?: boolean
-    scheduledUpdate?: boolean
-    blacklistInfo?: boolean
-    files?: boolean
-    blockedOwner?: boolean
-  }
-}
-
-function guessAdditionalAttributesFromQuery (query: VideosCommonQueryAfterSanitize): VideoFormattingJSONOptions {
-  if (!query?.include) return {}
-
-  return {
-    additionalAttributes: {
-      state: !!(query.include & VideoInclude.NOT_PUBLISHED_STATE),
-      waitTranscoding: !!(query.include & VideoInclude.NOT_PUBLISHED_STATE),
-      scheduledUpdate: !!(query.include & VideoInclude.NOT_PUBLISHED_STATE),
-      blacklistInfo: !!(query.include & VideoInclude.BLACKLISTED),
-      files: !!(query.include & VideoInclude.FILES),
-      blockedOwner: !!(query.include & VideoInclude.BLOCKED_OWNER)
-    }
-  }
-}
-
-function videoModelToFormattedJSON (video: MVideoFormattable, options: VideoFormattingJSONOptions = {}): Video {
-  const span = tracer.startSpan('peertube.VideoModel.toFormattedJSON')
-
-  const userHistory = isArray(video.UserVideoHistories) ? video.UserVideoHistories[0] : undefined
-
-  const videoObject: Video = {
-    id: video.id,
-    uuid: video.uuid,
-    shortUUID: uuidToShort(video.uuid),
-
-    url: video.url,
-
-    name: video.name,
-    category: {
-      id: video.category,
-      label: getCategoryLabel(video.category)
-    },
-    licence: {
-      id: video.licence,
-      label: getLicenceLabel(video.licence)
-    },
-    language: {
-      id: video.language,
-      label: getLanguageLabel(video.language)
-    },
-    privacy: {
-      id: video.privacy,
-      label: getPrivacyLabel(video.privacy)
-    },
-    nsfw: video.nsfw,
-
-    truncatedDescription: video.getTruncatedDescription(),
-    description: options && options.completeDescription === true
-      ? video.description
-      : video.getTruncatedDescription(),
-
-    isLocal: video.isOwned(),
-    duration: video.duration,
-
-    views: video.views,
-    viewers: VideoViewsManager.Instance.getViewers(video),
-
-    likes: video.likes,
-    dislikes: video.dislikes,
-    thumbnailPath: video.getMiniatureStaticPath(),
-    previewPath: video.getPreviewStaticPath(),
-    embedPath: video.getEmbedStaticPath(),
-    createdAt: video.createdAt,
-    updatedAt: video.updatedAt,
-    publishedAt: video.publishedAt,
-    originallyPublishedAt: video.originallyPublishedAt,
-
-    isLive: video.isLive,
-
-    account: video.VideoChannel.Account.toFormattedSummaryJSON(),
-    channel: video.VideoChannel.toFormattedSummaryJSON(),
-
-    userHistory: userHistory
-      ? { currentTime: userHistory.currentTime }
-      : undefined,
-
-    // Can be added by external plugins
-    pluginData: (video as any).pluginData
-  }
-
-  const add = options.additionalAttributes
-  if (add?.state === true) {
-    videoObject.state = {
-      id: video.state,
-      label: getStateLabel(video.state)
-    }
-  }
-
-  if (add?.waitTranscoding === true) {
-    videoObject.waitTranscoding = video.waitTranscoding
-  }
-
-  if (add?.scheduledUpdate === true && video.ScheduleVideoUpdate) {
-    videoObject.scheduledUpdate = {
-      updateAt: video.ScheduleVideoUpdate.updateAt,
-      privacy: video.ScheduleVideoUpdate.privacy || undefined
-    }
-  }
-
-  if (add?.blacklistInfo === true) {
-    videoObject.blacklisted = !!video.VideoBlacklist
-    videoObject.blacklistedReason = video.VideoBlacklist ? video.VideoBlacklist.reason : null
-  }
-
-  if (add?.blockedOwner === true) {
-    videoObject.blockedOwner = video.VideoChannel.Account.isBlocked()
-
-    const server = video.VideoChannel.Account.Actor.Server as MServer
-    videoObject.blockedServer = !!(server?.isBlocked())
-  }
-
-  if (add?.files === true) {
-    videoObject.streamingPlaylists = streamingPlaylistsModelToFormattedJSON(video, video.VideoStreamingPlaylists)
-    videoObject.files = videoFilesModelToFormattedJSON(video, video.VideoFiles)
-  }
-
-  span.end()
-
-  return videoObject
-}
-
-function videoModelToFormattedDetailsJSON (video: MVideoFormattableDetails): VideoDetails {
-  const span = tracer.startSpan('peertube.VideoModel.toFormattedDetailsJSON')
-
-  const videoJSON = video.toFormattedJSON({
-    completeDescription: true,
-    additionalAttributes: {
-      scheduledUpdate: true,
-      blacklistInfo: true,
-      files: true
-    }
-  }) as Video & Required<Pick<Video, 'files' | 'streamingPlaylists'>>
-
-  const tags = video.Tags ? video.Tags.map(t => t.name) : []
-
-  const detailsJSON = {
-    support: video.support,
-    descriptionPath: video.getDescriptionAPIPath(),
-    channel: video.VideoChannel.toFormattedJSON(),
-    account: video.VideoChannel.Account.toFormattedJSON(),
-    tags,
-    commentsEnabled: video.commentsEnabled,
-    downloadEnabled: video.downloadEnabled,
-    waitTranscoding: video.waitTranscoding,
-    state: {
-      id: video.state,
-      label: getStateLabel(video.state)
-    },
-
-    trackerUrls: video.getTrackerUrls()
-  }
-
-  span.end()
-
-  return Object.assign(videoJSON, detailsJSON)
-}
-
-function streamingPlaylistsModelToFormattedJSON (
-  video: MVideoFormattable,
-  playlists: MStreamingPlaylistRedundanciesOpt[]
-): VideoStreamingPlaylist[] {
-  if (isArray(playlists) === false) return []
-
-  return playlists
-    .map(playlist => {
-      const redundancies = isArray(playlist.RedundancyVideos)
-        ? playlist.RedundancyVideos.map(r => ({ baseUrl: r.fileUrl }))
-        : []
-
-      const files = videoFilesModelToFormattedJSON(video, playlist.VideoFiles)
-
-      return {
-        id: playlist.id,
-        type: playlist.type,
-        playlistUrl: playlist.getMasterPlaylistUrl(video),
-        segmentsSha256Url: playlist.getSha256SegmentsUrl(video),
-        redundancies,
-        files
-      }
-    })
-}
-
-function sortByResolutionDesc (fileA: MVideoFile, fileB: MVideoFile) {
-  if (fileA.resolution < fileB.resolution) return 1
-  if (fileA.resolution === fileB.resolution) return 0
-  return -1
-}
-
-function videoFilesModelToFormattedJSON (
-  video: MVideoFormattable,
-  videoFiles: MVideoFileRedundanciesOpt[],
-  options: {
-    includeMagnet?: boolean // default true
-  } = {}
-): VideoFile[] {
-  const { includeMagnet = true } = options
-
-  const trackerUrls = includeMagnet
-    ? video.getTrackerUrls()
-    : []
-
-  return (videoFiles || [])
-    .filter(f => !f.isLive())
-    .sort(sortByResolutionDesc)
-    .map(videoFile => {
-      return {
-        id: videoFile.id,
-
-        resolution: {
-          id: videoFile.resolution,
-          label: videoFile.resolution === 0 ? 'Audio' : `${videoFile.resolution}p`
-        },
-
-        magnetUri: includeMagnet && videoFile.hasTorrent()
-          ? generateMagnetUri(video, videoFile, trackerUrls)
-          : undefined,
-
-        size: videoFile.size,
-        fps: videoFile.fps,
-
-        torrentUrl: videoFile.getTorrentUrl(),
-        torrentDownloadUrl: videoFile.getTorrentDownloadUrl(),
-
-        fileUrl: videoFile.getFileUrl(video),
-        fileDownloadUrl: videoFile.getFileDownloadUrl(video),
-
-        metadataUrl: videoFile.metadataUrl ?? getLocalVideoFileMetadataUrl(video, videoFile)
-      } as VideoFile
-    })
-}
-
-function addVideoFilesInAPAcc (options: {
-  acc: ActivityUrlObject[] | ActivityTagObject[]
-  video: MVideo
-  files: MVideoFile[]
-  user?: MUserId
-}) {
-  const { acc, video, files } = options
-
-  const trackerUrls = video.getTrackerUrls()
-
-  const sortedFiles = (files || [])
-    .filter(f => !f.isLive())
-    .sort(sortByResolutionDesc)
-
-  for (const file of sortedFiles) {
-    acc.push({
-      type: 'Link',
-      mediaType: MIMETYPES.VIDEO.EXT_MIMETYPE[file.extname] as any,
-      href: file.getFileUrl(video),
-      height: file.resolution,
-      size: file.size,
-      fps: file.fps
-    })
-
-    acc.push({
-      type: 'Link',
-      rel: [ 'metadata', MIMETYPES.VIDEO.EXT_MIMETYPE[file.extname] ],
-      mediaType: 'application/json' as 'application/json',
-      href: getLocalVideoFileMetadataUrl(video, file),
-      height: file.resolution,
-      fps: file.fps
-    })
-
-    if (file.hasTorrent()) {
-      acc.push({
-        type: 'Link',
-        mediaType: 'application/x-bittorrent' as 'application/x-bittorrent',
-        href: file.getTorrentUrl(),
-        height: file.resolution
-      })
-
-      acc.push({
-        type: 'Link',
-        mediaType: 'application/x-bittorrent;x-scheme-handler/magnet' as 'application/x-bittorrent;x-scheme-handler/magnet',
-        href: generateMagnetUri(video, file, trackerUrls),
-        height: file.resolution
-      })
-    }
-  }
-}
-
-function videoModelToActivityPubObject (video: MVideoAP): VideoObject {
-  if (!video.Tags) video.Tags = []
-
-  const tag = video.Tags.map(t => ({
-    type: 'Hashtag' as 'Hashtag',
-    name: t.name
-  }))
-
-  let language
-  if (video.language) {
-    language = {
-      identifier: video.language,
-      name: getLanguageLabel(video.language)
-    }
-  }
-
-  let category
-  if (video.category) {
-    category = {
-      identifier: video.category + '',
-      name: getCategoryLabel(video.category)
-    }
-  }
-
-  let licence
-  if (video.licence) {
-    licence = {
-      identifier: video.licence + '',
-      name: getLicenceLabel(video.licence)
-    }
-  }
-
-  const url: ActivityUrlObject[] = [
-    // HTML url should be the first element in the array so Mastodon correctly displays the embed
-    {
-      type: 'Link',
-      mediaType: 'text/html',
-      href: WEBSERVER.URL + '/videos/watch/' + video.uuid
-    }
-  ]
-
-  addVideoFilesInAPAcc({ acc: url, video, files: video.VideoFiles || [] })
-
-  for (const playlist of (video.VideoStreamingPlaylists || [])) {
-    const tag = playlist.p2pMediaLoaderInfohashes
-                  .map(i => ({ type: 'Infohash' as 'Infohash', name: i })) as ActivityTagObject[]
-    tag.push({
-      type: 'Link',
-      name: 'sha256',
-      mediaType: 'application/json' as 'application/json',
-      href: playlist.getSha256SegmentsUrl(video)
-    })
-
-    addVideoFilesInAPAcc({ acc: tag, video, files: playlist.VideoFiles || [] })
-
-    url.push({
-      type: 'Link',
-      mediaType: 'application/x-mpegURL' as 'application/x-mpegURL',
-      href: playlist.getMasterPlaylistUrl(video),
-      tag
-    })
-  }
-
-  for (const trackerUrl of video.getTrackerUrls()) {
-    const rel2 = trackerUrl.startsWith('http')
-      ? 'http'
-      : 'websocket'
-
-    url.push({
-      type: 'Link',
-      name: `tracker-${rel2}`,
-      rel: [ 'tracker', rel2 ],
-      href: trackerUrl
-    })
-  }
-
-  const subtitleLanguage = []
-  for (const caption of video.VideoCaptions) {
-    subtitleLanguage.push({
-      identifier: caption.language,
-      name: VideoCaptionModel.getLanguageLabel(caption.language),
-      url: caption.getFileUrl(video)
-    })
-  }
-
-  const icons = [ video.getMiniature(), video.getPreview() ]
-
-  return {
-    type: 'Video' as 'Video',
-    id: video.url,
-    name: video.name,
-    duration: getActivityStreamDuration(video.duration),
-    uuid: video.uuid,
-    tag,
-    category,
-    licence,
-    language,
-    views: video.views,
-    sensitive: video.nsfw,
-    waitTranscoding: video.waitTranscoding,
-
-    state: video.state,
-    commentsEnabled: video.commentsEnabled,
-    downloadEnabled: video.downloadEnabled,
-    published: video.publishedAt.toISOString(),
-
-    originallyPublishedAt: video.originallyPublishedAt
-      ? video.originallyPublishedAt.toISOString()
-      : null,
-
-    updated: video.updatedAt.toISOString(),
-
-    mediaType: 'text/markdown',
-    content: video.description,
-    support: video.support,
-
-    subtitleLanguage,
-
-    icon: icons.map(i => ({
-      type: 'Image',
-      url: i.getOriginFileUrl(video),
-      mediaType: 'image/jpeg',
-      width: i.width,
-      height: i.height
-    })),
-
-    url,
-
-    likes: getLocalVideoLikesActivityPubUrl(video),
-    dislikes: getLocalVideoDislikesActivityPubUrl(video),
-    shares: getLocalVideoSharesActivityPubUrl(video),
-    comments: getLocalVideoCommentsActivityPubUrl(video),
-
-    attributedTo: [
-      {
-        type: 'Person',
-        id: video.VideoChannel.Account.Actor.url
-      },
-      {
-        type: 'Group',
-        id: video.VideoChannel.Actor.url
-      }
-    ],
-
-    ...buildLiveAPAttributes(video)
-  }
-}
-
-function getCategoryLabel (id: number) {
-  return VIDEO_CATEGORIES[id] || 'Unknown'
-}
-
-function getLicenceLabel (id: number) {
-  return VIDEO_LICENCES[id] || 'Unknown'
-}
-
-function getLanguageLabel (id: string) {
-  return VIDEO_LANGUAGES[id] || 'Unknown'
-}
-
-function getPrivacyLabel (id: number) {
-  return VIDEO_PRIVACIES[id] || 'Unknown'
-}
-
-function getStateLabel (id: number) {
-  return VIDEO_STATES[id] || 'Unknown'
-}
-
-export {
-  videoModelToFormattedJSON,
-  videoModelToFormattedDetailsJSON,
-  videoFilesModelToFormattedJSON,
-  videoModelToActivityPubObject,
-
-  guessAdditionalAttributesFromQuery,
-
-  getCategoryLabel,
-  getLicenceLabel,
-  getLanguageLabel,
-  getPrivacyLabel,
-  getStateLabel
-}
-
-// ---------------------------------------------------------------------------
-
-function buildLiveAPAttributes (video: MVideoAP) {
-  if (!video.isLive) {
-    return {
-      isLiveBroadcast: false,
-      liveSaveReplay: null,
-      permanentLive: null,
-      latencyMode: null
-    }
-  }
-
-  return {
-    isLiveBroadcast: true,
-    liveSaveReplay: video.VideoLive.saveReplay,
-    permanentLive: video.VideoLive.permanentLive,
-    latencyMode: video.VideoLive.latencyMode
-  }
-}
diff --git a/server/models/video/sql/video/shared/abstract-video-query-builder.ts b/server/models/video/sql/video/shared/abstract-video-query-builder.ts
index cbd57ad8c..56a00aa0c 100644
--- a/server/models/video/sql/video/shared/abstract-video-query-builder.ts
+++ b/server/models/video/sql/video/shared/abstract-video-query-builder.ts
@@ -111,7 +111,7 @@ export class AbstractVideoQueryBuilder extends AbstractRunQuery {
     }
   }
 
-  protected includeWebtorrentFiles () {
+  protected includeWebVideoFiles () {
     this.addJoin('LEFT JOIN "videoFile" AS "VideoFiles" ON "VideoFiles"."videoId" = "video"."id"')
 
     this.attributes = {
@@ -263,7 +263,7 @@ export class AbstractVideoQueryBuilder extends AbstractRunQuery {
     }
   }
 
-  protected includeWebTorrentRedundancies () {
+  protected includeWebVideoRedundancies () {
     this.addJoin(
       'LEFT OUTER JOIN "videoRedundancy" AS "VideoFiles->RedundancyVideos" ON ' +
         '"VideoFiles"."id" = "VideoFiles->RedundancyVideos"."videoFileId"'
diff --git a/server/models/video/sql/video/shared/video-file-query-builder.ts b/server/models/video/sql/video/shared/video-file-query-builder.ts
index cc53a4860..196b72b43 100644
--- a/server/models/video/sql/video/shared/video-file-query-builder.ts
+++ b/server/models/video/sql/video/shared/video-file-query-builder.ts
@@ -14,7 +14,7 @@ export type FileQueryOptions = {
 
 /**
  *
- * Fetch files (webtorrent and streaming playlist) according to a video
+ * Fetch files (web videos and streaming playlist) according to a video
  *
  */
 
@@ -25,8 +25,8 @@ export class VideoFileQueryBuilder extends AbstractVideoQueryBuilder {
     super(sequelize, 'get')
   }
 
-  queryWebTorrentVideos (options: FileQueryOptions) {
-    this.buildWebtorrentFilesQuery(options)
+  queryWebVideos (options: FileQueryOptions) {
+    this.buildWebVideoFilesQuery(options)
 
     return this.runQuery(options)
   }
@@ -37,15 +37,15 @@ export class VideoFileQueryBuilder extends AbstractVideoQueryBuilder {
     return this.runQuery(options)
   }
 
-  private buildWebtorrentFilesQuery (options: FileQueryOptions) {
+  private buildWebVideoFilesQuery (options: FileQueryOptions) {
     this.attributes = {
       '"video"."id"': ''
     }
 
-    this.includeWebtorrentFiles()
+    this.includeWebVideoFiles()
 
     if (options.includeRedundancy) {
-      this.includeWebTorrentRedundancies()
+      this.includeWebVideoRedundancies()
     }
 
     this.whereId(options)
diff --git a/server/models/video/sql/video/shared/video-model-builder.ts b/server/models/video/sql/video/shared/video-model-builder.ts
index 0a2beb7db..740aa842f 100644
--- a/server/models/video/sql/video/shared/video-model-builder.ts
+++ b/server/models/video/sql/video/shared/video-model-builder.ts
@@ -60,10 +60,10 @@ export class VideoModelBuilder {
   buildVideosFromRows (options: {
     rows: SQLRow[]
     include?: VideoInclude
-    rowsWebTorrentFiles?: SQLRow[]
+    rowsWebVideoFiles?: SQLRow[]
     rowsStreamingPlaylist?: SQLRow[]
   }) {
-    const { rows, rowsWebTorrentFiles, rowsStreamingPlaylist, include } = options
+    const { rows, rowsWebVideoFiles, rowsStreamingPlaylist, include } = options
 
     this.reinit()
 
@@ -85,8 +85,8 @@ export class VideoModelBuilder {
         this.addActorAvatar(row, 'VideoChannel.Account.Actor', accountActor)
       }
 
-      if (!rowsWebTorrentFiles) {
-        this.addWebTorrentFile(row, videoModel)
+      if (!rowsWebVideoFiles) {
+        this.addWebVideoFile(row, videoModel)
       }
 
       if (!rowsStreamingPlaylist) {
@@ -112,7 +112,7 @@ export class VideoModelBuilder {
       }
     }
 
-    this.grabSeparateWebTorrentFiles(rowsWebTorrentFiles)
+    this.grabSeparateWebVideoFiles(rowsWebVideoFiles)
     this.grabSeparateStreamingPlaylistFiles(rowsStreamingPlaylist)
 
     return this.videos
@@ -140,15 +140,15 @@ export class VideoModelBuilder {
     this.videos = []
   }
 
-  private grabSeparateWebTorrentFiles (rowsWebTorrentFiles?: SQLRow[]) {
-    if (!rowsWebTorrentFiles) return
+  private grabSeparateWebVideoFiles (rowsWebVideoFiles?: SQLRow[]) {
+    if (!rowsWebVideoFiles) return
 
-    for (const row of rowsWebTorrentFiles) {
+    for (const row of rowsWebVideoFiles) {
       const id = row['VideoFiles.id']
       if (!id) continue
 
       const videoModel = this.videosMemo[row.id]
-      this.addWebTorrentFile(row, videoModel)
+      this.addWebVideoFile(row, videoModel)
       this.addRedundancy(row, 'VideoFiles', this.videoFileMemo[id])
     }
   }
@@ -258,7 +258,7 @@ export class VideoModelBuilder {
     this.thumbnailsDone.add(id)
   }
 
-  private addWebTorrentFile (row: SQLRow, videoModel: VideoModel) {
+  private addWebVideoFile (row: SQLRow, videoModel: VideoModel) {
     const id = row['VideoFiles.id']
     if (!id || this.videoFileMemo[id]) return
 
diff --git a/server/models/video/sql/video/shared/video-table-attributes.ts b/server/models/video/sql/video/shared/video-table-attributes.ts
index 34967cd20..e0fa9d7c1 100644
--- a/server/models/video/sql/video/shared/video-table-attributes.ts
+++ b/server/models/video/sql/video/shared/video-table-attributes.ts
@@ -60,6 +60,7 @@ export class VideoTableAttributes {
         'height',
         'width',
         'fileUrl',
+        'onDisk',
         'automaticallyGenerated',
         'videoId',
         'videoPlaylistId',
diff --git a/server/models/video/sql/video/video-model-get-query-builder.ts b/server/models/video/sql/video/video-model-get-query-builder.ts
index 8e90ff641..3f43d4d92 100644
--- a/server/models/video/sql/video/video-model-get-query-builder.ts
+++ b/server/models/video/sql/video/video-model-get-query-builder.ts
@@ -35,7 +35,7 @@ export type BuildVideoGetQueryOptions = {
 
 export class VideoModelGetQueryBuilder {
   videoQueryBuilder: VideosModelGetQuerySubBuilder
-  webtorrentFilesQueryBuilder: VideoFileQueryBuilder
+  webVideoFilesQueryBuilder: VideoFileQueryBuilder
   streamingPlaylistFilesQueryBuilder: VideoFileQueryBuilder
 
   private readonly videoModelBuilder: VideoModelBuilder
@@ -44,7 +44,7 @@ export class VideoModelGetQueryBuilder {
 
   constructor (protected readonly sequelize: Sequelize) {
     this.videoQueryBuilder = new VideosModelGetQuerySubBuilder(sequelize)
-    this.webtorrentFilesQueryBuilder = new VideoFileQueryBuilder(sequelize)
+    this.webVideoFilesQueryBuilder = new VideoFileQueryBuilder(sequelize)
     this.streamingPlaylistFilesQueryBuilder = new VideoFileQueryBuilder(sequelize)
 
     this.videoModelBuilder = new VideoModelBuilder('get', new VideoTableAttributes('get'))
@@ -57,11 +57,11 @@ export class VideoModelGetQueryBuilder {
       includeRedundancy: this.shouldIncludeRedundancies(options)
     }
 
-    const [ videoRows, webtorrentFilesRows, streamingPlaylistFilesRows ] = await Promise.all([
+    const [ videoRows, webVideoFilesRows, streamingPlaylistFilesRows ] = await Promise.all([
       this.videoQueryBuilder.queryVideos(options),
 
       VideoModelGetQueryBuilder.videoFilesInclude.has(options.type)
-        ? this.webtorrentFilesQueryBuilder.queryWebTorrentVideos(fileQueryOptions)
+        ? this.webVideoFilesQueryBuilder.queryWebVideos(fileQueryOptions)
         : Promise.resolve(undefined),
 
       VideoModelGetQueryBuilder.videoFilesInclude.has(options.type)
@@ -71,7 +71,7 @@ export class VideoModelGetQueryBuilder {
 
     const videos = this.videoModelBuilder.buildVideosFromRows({
       rows: videoRows,
-      rowsWebTorrentFiles: webtorrentFilesRows,
+      rowsWebVideoFiles: webVideoFilesRows,
       rowsStreamingPlaylist: streamingPlaylistFilesRows
     })
 
@@ -92,7 +92,7 @@ export class VideoModelGetQueryBuilder {
 export class VideosModelGetQuerySubBuilder extends AbstractVideoQueryBuilder {
   protected attributes: { [key: string]: string }
 
-  protected webtorrentFilesQuery: string
+  protected webVideoFilesQuery: string
   protected streamingPlaylistFilesQuery: string
 
   private static readonly trackersInclude = new Set<GetType>([ 'api' ])
diff --git a/server/models/video/sql/video/videos-id-list-query-builder.ts b/server/models/video/sql/video/videos-id-list-query-builder.ts
index cba77c1d1..7f2376102 100644
--- a/server/models/video/sql/video/videos-id-list-query-builder.ts
+++ b/server/models/video/sql/video/videos-id-list-query-builder.ts
@@ -48,7 +48,9 @@ export type BuildVideosListQueryOptions = {
 
   hasFiles?: boolean
   hasHLSFiles?: boolean
-  hasWebtorrentFiles?: boolean
+
+  hasWebVideoFiles?: boolean
+  hasWebtorrentFiles?: boolean // TODO: Remove in v7
 
   accountId?: number
   videoChannelId?: number
@@ -175,7 +177,9 @@ export class VideosIdListQueryBuilder extends AbstractRunQuery {
     }
 
     if (exists(options.hasWebtorrentFiles)) {
-      this.whereWebTorrentFileExists(options.hasWebtorrentFiles)
+      this.whereWebVideoFileExists(options.hasWebtorrentFiles)
+    } else if (exists(options.hasWebVideoFiles)) {
+      this.whereWebVideoFileExists(options.hasWebVideoFiles)
     }
 
     if (exists(options.hasHLSFiles)) {
@@ -400,18 +404,18 @@ export class VideosIdListQueryBuilder extends AbstractRunQuery {
   }
 
   private whereFileExists () {
-    this.and.push(`(${this.buildWebTorrentFileExistsQuery(true)} OR ${this.buildHLSFileExistsQuery(true)})`)
+    this.and.push(`(${this.buildWebVideoFileExistsQuery(true)} OR ${this.buildHLSFileExistsQuery(true)})`)
   }
 
-  private whereWebTorrentFileExists (exists: boolean) {
-    this.and.push(this.buildWebTorrentFileExistsQuery(exists))
+  private whereWebVideoFileExists (exists: boolean) {
+    this.and.push(this.buildWebVideoFileExistsQuery(exists))
   }
 
   private whereHLSFileExists (exists: boolean) {
     this.and.push(this.buildHLSFileExistsQuery(exists))
   }
 
-  private buildWebTorrentFileExistsQuery (exists: boolean) {
+  private buildWebVideoFileExistsQuery (exists: boolean) {
     const prefix = exists ? '' : 'NOT '
 
     return prefix + 'EXISTS (SELECT 1 FROM "videoFile" WHERE "videoFile"."videoId" = "video"."id")'
diff --git a/server/models/video/sql/video/videos-model-list-query-builder.ts b/server/models/video/sql/video/videos-model-list-query-builder.ts
index 3fdac4ed3..b73dc28cd 100644
--- a/server/models/video/sql/video/videos-model-list-query-builder.ts
+++ b/server/models/video/sql/video/videos-model-list-query-builder.ts
@@ -18,7 +18,7 @@ export class VideosModelListQueryBuilder extends AbstractVideoQueryBuilder {
   private innerQuery: string
   private innerSort: string
 
-  webtorrentFilesQueryBuilder: VideoFileQueryBuilder
+  webVideoFilesQueryBuilder: VideoFileQueryBuilder
   streamingPlaylistFilesQueryBuilder: VideoFileQueryBuilder
 
   private readonly videoModelBuilder: VideoModelBuilder
@@ -27,7 +27,7 @@ export class VideosModelListQueryBuilder extends AbstractVideoQueryBuilder {
     super(sequelize, 'list')
 
     this.videoModelBuilder = new VideoModelBuilder(this.mode, this.tables)
-    this.webtorrentFilesQueryBuilder = new VideoFileQueryBuilder(sequelize)
+    this.webVideoFilesQueryBuilder = new VideoFileQueryBuilder(sequelize)
     this.streamingPlaylistFilesQueryBuilder = new VideoFileQueryBuilder(sequelize)
   }
 
@@ -48,12 +48,12 @@ export class VideosModelListQueryBuilder extends AbstractVideoQueryBuilder {
           includeRedundancy: false
         }
 
-        const [ rowsWebTorrentFiles, rowsStreamingPlaylist ] = await Promise.all([
-          this.webtorrentFilesQueryBuilder.queryWebTorrentVideos(fileQueryOptions),
+        const [ rowsWebVideoFiles, rowsStreamingPlaylist ] = await Promise.all([
+          this.webVideoFilesQueryBuilder.queryWebVideos(fileQueryOptions),
           this.streamingPlaylistFilesQueryBuilder.queryStreamingPlaylistVideos(fileQueryOptions)
         ])
 
-        return this.videoModelBuilder.buildVideosFromRows({ rows, include: options.include, rowsStreamingPlaylist, rowsWebTorrentFiles })
+        return this.videoModelBuilder.buildVideosFromRows({ rows, include: options.include, rowsStreamingPlaylist, rowsWebVideoFiles })
       }
     }
 
diff --git a/server/models/video/storyboard.ts b/server/models/video/storyboard.ts
new file mode 100644
index 000000000..65a044c98
--- /dev/null
+++ b/server/models/video/storyboard.ts
@@ -0,0 +1,169 @@
+import { remove } from 'fs-extra'
+import { join } from 'path'
+import { AfterDestroy, AllowNull, BelongsTo, Column, CreatedAt, DataType, ForeignKey, Model, Table, UpdatedAt } from 'sequelize-typescript'
+import { CONFIG } from '@server/initializers/config'
+import { MStoryboard, MStoryboardVideo, MVideo } from '@server/types/models'
+import { Storyboard } from '@shared/models'
+import { AttributesOnly } from '@shared/typescript-utils'
+import { logger } from '../../helpers/logger'
+import { CONSTRAINTS_FIELDS, LAZY_STATIC_PATHS, WEBSERVER } from '../../initializers/constants'
+import { VideoModel } from './video'
+import { Transaction } from 'sequelize'
+
+@Table({
+  tableName: 'storyboard',
+  indexes: [
+    {
+      fields: [ 'videoId' ],
+      unique: true
+    },
+    {
+      fields: [ 'filename' ],
+      unique: true
+    }
+  ]
+})
+export class StoryboardModel extends Model<Partial<AttributesOnly<StoryboardModel>>> {
+
+  @AllowNull(false)
+  @Column
+  filename: string
+
+  @AllowNull(false)
+  @Column
+  totalHeight: number
+
+  @AllowNull(false)
+  @Column
+  totalWidth: number
+
+  @AllowNull(false)
+  @Column
+  spriteHeight: number
+
+  @AllowNull(false)
+  @Column
+  spriteWidth: number
+
+  @AllowNull(false)
+  @Column
+  spriteDuration: number
+
+  @AllowNull(true)
+  @Column(DataType.STRING(CONSTRAINTS_FIELDS.COMMONS.URL.max))
+  fileUrl: string
+
+  @ForeignKey(() => VideoModel)
+  @Column
+  videoId: number
+
+  @BelongsTo(() => VideoModel, {
+    foreignKey: {
+      allowNull: true
+    },
+    onDelete: 'CASCADE'
+  })
+  Video: VideoModel
+
+  @CreatedAt
+  createdAt: Date
+
+  @UpdatedAt
+  updatedAt: Date
+
+  @AfterDestroy
+  static removeInstanceFile (instance: StoryboardModel) {
+    logger.info('Removing storyboard file %s.', instance.filename)
+
+    // Don't block the transaction
+    instance.removeFile()
+            .catch(err => logger.error('Cannot remove storyboard file %s.', instance.filename, { err }))
+  }
+
+  static loadByVideo (videoId: number, transaction?: Transaction): Promise<MStoryboard> {
+    const query = {
+      where: {
+        videoId
+      },
+      transaction
+    }
+
+    return StoryboardModel.findOne(query)
+  }
+
+  static loadByFilename (filename: string): Promise<MStoryboard> {
+    const query = {
+      where: {
+        filename
+      }
+    }
+
+    return StoryboardModel.findOne(query)
+  }
+
+  static loadWithVideoByFilename (filename: string): Promise<MStoryboardVideo> {
+    const query = {
+      where: {
+        filename
+      },
+      include: [
+        {
+          model: VideoModel.unscoped(),
+          required: true
+        }
+      ]
+    }
+
+    return StoryboardModel.findOne(query)
+  }
+
+  // ---------------------------------------------------------------------------
+
+  static async listStoryboardsOf (video: MVideo): Promise<MStoryboardVideo[]> {
+    const query = {
+      where: {
+        videoId: video.id
+      }
+    }
+
+    const storyboards = await StoryboardModel.findAll<MStoryboard>(query)
+
+    return storyboards.map(s => Object.assign(s, { Video: video }))
+  }
+
+  // ---------------------------------------------------------------------------
+
+  getOriginFileUrl (video: MVideo) {
+    if (video.isOwned()) {
+      return WEBSERVER.URL + this.getLocalStaticPath()
+    }
+
+    return this.fileUrl
+  }
+
+  getLocalStaticPath () {
+    return LAZY_STATIC_PATHS.STORYBOARDS + this.filename
+  }
+
+  getPath () {
+    return join(CONFIG.STORAGE.STORYBOARDS_DIR, this.filename)
+  }
+
+  removeFile () {
+    return remove(this.getPath())
+  }
+
+  toFormattedJSON (this: MStoryboardVideo): Storyboard {
+    return {
+      storyboardPath: this.getLocalStaticPath(),
+
+      totalHeight: this.totalHeight,
+      totalWidth: this.totalWidth,
+
+      spriteWidth: this.spriteWidth,
+      spriteHeight: this.spriteHeight,
+
+      spriteDuration: this.spriteDuration
+    }
+  }
+}
diff --git a/server/models/video/thumbnail.ts b/server/models/video/thumbnail.ts
index a4ac581e5..1722acdb4 100644
--- a/server/models/video/thumbnail.ts
+++ b/server/models/video/thumbnail.ts
@@ -21,7 +21,7 @@ import { AttributesOnly } from '@shared/typescript-utils'
 import { ThumbnailType } from '../../../shared/models/videos/thumbnail.type'
 import { logger } from '../../helpers/logger'
 import { CONFIG } from '../../initializers/config'
-import { CONSTRAINTS_FIELDS, LAZY_STATIC_PATHS, STATIC_PATHS, WEBSERVER } from '../../initializers/constants'
+import { CONSTRAINTS_FIELDS, LAZY_STATIC_PATHS, WEBSERVER } from '../../initializers/constants'
 import { VideoModel } from './video'
 import { VideoPlaylistModel } from './video-playlist'
 
@@ -69,6 +69,10 @@ export class ThumbnailModel extends Model<Partial<AttributesOnly<ThumbnailModel>
   @Column
   automaticallyGenerated: boolean
 
+  @AllowNull(false)
+  @Column
+  onDisk: boolean
+
   @ForeignKey(() => VideoModel)
   @Column
   videoId: number
@@ -106,7 +110,7 @@ export class ThumbnailModel extends Model<Partial<AttributesOnly<ThumbnailModel>
     [ThumbnailType.MINIATURE]: {
       label: 'miniature',
       directory: CONFIG.STORAGE.THUMBNAILS_DIR,
-      staticPath: STATIC_PATHS.THUMBNAILS
+      staticPath: LAZY_STATIC_PATHS.THUMBNAILS
     },
     [ThumbnailType.PREVIEW]: {
       label: 'preview',
@@ -197,4 +201,8 @@ export class ThumbnailModel extends Model<Partial<AttributesOnly<ThumbnailModel>
 
     this.previousThumbnailFilename = undefined
   }
+
+  isOwned () {
+    return !this.fileUrl
+  }
 }
diff --git a/server/models/video/video-caption.ts b/server/models/video/video-caption.ts
index 1fb1cae82..dd4cefd65 100644
--- a/server/models/video/video-caption.ts
+++ b/server/models/video/video-caption.ts
@@ -15,7 +15,7 @@ import {
   Table,
   UpdatedAt
 } from 'sequelize-typescript'
-import { MVideo, MVideoCaption, MVideoCaptionFormattable, MVideoCaptionVideo } from '@server/types/models'
+import { MVideo, MVideoCaption, MVideoCaptionFormattable, MVideoCaptionLanguageUrl, MVideoCaptionVideo } from '@server/types/models'
 import { buildUUID } from '@shared/extra-utils'
 import { AttributesOnly } from '@shared/typescript-utils'
 import { VideoCaption } from '../../../shared/models/videos/caption/video-caption.model'
@@ -225,7 +225,7 @@ export class VideoCaptionModel extends Model<Partial<AttributesOnly<VideoCaption
     }
   }
 
-  getCaptionStaticPath (this: MVideoCaption) {
+  getCaptionStaticPath (this: MVideoCaptionLanguageUrl) {
     return join(LAZY_STATIC_PATHS.VIDEO_CAPTIONS, this.filename)
   }
 
@@ -233,9 +233,7 @@ export class VideoCaptionModel extends Model<Partial<AttributesOnly<VideoCaption
     return remove(CONFIG.STORAGE.CAPTIONS_DIR + this.filename)
   }
 
-  getFileUrl (video: MVideo) {
-    if (!this.Video) this.Video = video as VideoModel
-
+  getFileUrl (this: MVideoCaptionLanguageUrl, video: MVideo) {
     if (video.isOwned()) return WEBSERVER.URL + this.getCaptionStaticPath()
 
     return this.fileUrl
diff --git a/server/models/video/video-change-ownership.ts b/server/models/video/video-change-ownership.ts
index 2db4b523a..26f072f4f 100644
--- a/server/models/video/video-change-ownership.ts
+++ b/server/models/video/video-change-ownership.ts
@@ -45,7 +45,7 @@ enum ScopeNames {
       {
         model: VideoModel.scope([
           VideoScopeNames.WITH_THUMBNAILS,
-          VideoScopeNames.WITH_WEBTORRENT_FILES,
+          VideoScopeNames.WITH_WEB_VIDEO_FILES,
           VideoScopeNames.WITH_STREAMING_PLAYLISTS,
           VideoScopeNames.WITH_ACCOUNT_DETAILS
         ]),
diff --git a/server/models/video/video-file.ts b/server/models/video/video-file.ts
index 07bc13de1..ee34ad2ff 100644
--- a/server/models/video/video-file.ts
+++ b/server/models/video/video-file.ts
@@ -26,8 +26,8 @@ import { buildRemoteVideoBaseUrl } from '@server/lib/activitypub/url'
 import {
   getHLSPrivateFileUrl,
   getHLSPublicFileUrl,
-  getWebTorrentPrivateFileUrl,
-  getWebTorrentPublicFileUrl
+  getWebVideoPrivateFileUrl,
+  getWebVideoPublicFileUrl
 } from '@server/lib/object-storage'
 import { getFSTorrentFilePath } from '@server/lib/paths'
 import { isVideoInPrivateDirectory } from '@server/lib/video-privacy'
@@ -276,15 +276,15 @@ export class VideoFileModel extends Model<Partial<AttributesOnly<VideoFileModel>
 
   static async doesOwnedTorrentFileExist (filename: string) {
     const query = 'SELECT 1 FROM "videoFile" ' +
-                  'LEFT JOIN "video" "webtorrent" ON "webtorrent"."id" = "videoFile"."videoId" AND "webtorrent"."remote" IS FALSE ' +
+                  'LEFT JOIN "video" "webvideo" ON "webvideo"."id" = "videoFile"."videoId" AND "webvideo"."remote" IS FALSE ' +
                   'LEFT JOIN "videoStreamingPlaylist" ON "videoStreamingPlaylist"."id" = "videoFile"."videoStreamingPlaylistId" ' +
                   'LEFT JOIN "video" "hlsVideo" ON "hlsVideo"."id" = "videoStreamingPlaylist"."videoId" AND "hlsVideo"."remote" IS FALSE ' +
-                  'WHERE "torrentFilename" = $filename AND ("hlsVideo"."id" IS NOT NULL OR "webtorrent"."id" IS NOT NULL) LIMIT 1'
+                  'WHERE "torrentFilename" = $filename AND ("hlsVideo"."id" IS NOT NULL OR "webvideo"."id" IS NOT NULL) LIMIT 1'
 
     return doesExist(this.sequelize, query, { filename })
   }
 
-  static async doesOwnedWebTorrentVideoFileExist (filename: string) {
+  static async doesOwnedWebVideoFileExist (filename: string) {
     const query = 'SELECT 1 FROM "videoFile" INNER JOIN "video" ON "video"."id" = "videoFile"."videoId" AND "video"."remote" IS FALSE ' +
                   `WHERE "filename" = $filename AND "storage" = ${VideoStorage.FILE_SYSTEM} LIMIT 1`
 
@@ -378,7 +378,7 @@ export class VideoFileModel extends Model<Partial<AttributesOnly<VideoFileModel>
   }
 
   static getStats () {
-    const webtorrentFilesQuery: FindOptions = {
+    const webVideoFilesQuery: FindOptions = {
       include: [
         {
           attributes: [],
@@ -412,10 +412,10 @@ export class VideoFileModel extends Model<Partial<AttributesOnly<VideoFileModel>
     }
 
     return Promise.all([
-      VideoFileModel.aggregate('size', 'SUM', webtorrentFilesQuery),
+      VideoFileModel.aggregate('size', 'SUM', webVideoFilesQuery),
       VideoFileModel.aggregate('size', 'SUM', hlsFilesQuery)
-    ]).then(([ webtorrentResult, hlsResult ]) => ({
-      totalLocalVideoFilesSize: parseAggregateResult(webtorrentResult) + parseAggregateResult(hlsResult)
+    ]).then(([ webVideoResult, hlsResult ]) => ({
+      totalLocalVideoFilesSize: parseAggregateResult(webVideoResult) + parseAggregateResult(hlsResult)
     }))
   }
 
@@ -433,7 +433,7 @@ export class VideoFileModel extends Model<Partial<AttributesOnly<VideoFileModel>
 
     const element = mode === 'streaming-playlist'
       ? await VideoFileModel.loadHLSFile({ ...baseFind, playlistId: videoFile.videoStreamingPlaylistId })
-      : await VideoFileModel.loadWebTorrentFile({ ...baseFind, videoId: videoFile.videoId })
+      : await VideoFileModel.loadWebVideoFile({ ...baseFind, videoId: videoFile.videoId })
 
     if (!element) return videoFile.save({ transaction })
 
@@ -444,7 +444,7 @@ export class VideoFileModel extends Model<Partial<AttributesOnly<VideoFileModel>
     return element.save({ transaction })
   }
 
-  static async loadWebTorrentFile (options: {
+  static async loadWebVideoFile (options: {
     videoId: number
     fps: number
     resolution: number
@@ -523,7 +523,7 @@ export class VideoFileModel extends Model<Partial<AttributesOnly<VideoFileModel>
       return getHLSPrivateFileUrl(video, this.filename)
     }
 
-    return getWebTorrentPrivateFileUrl(this.filename)
+    return getWebVideoPrivateFileUrl(this.filename)
   }
 
   private getPublicObjectStorageUrl () {
@@ -531,7 +531,7 @@ export class VideoFileModel extends Model<Partial<AttributesOnly<VideoFileModel>
       return getHLSPublicFileUrl(this.fileUrl)
     }
 
-    return getWebTorrentPublicFileUrl(this.fileUrl)
+    return getWebVideoPublicFileUrl(this.fileUrl)
   }
 
   // ---------------------------------------------------------------------------
@@ -553,15 +553,15 @@ export class VideoFileModel extends Model<Partial<AttributesOnly<VideoFileModel>
   getFileStaticPath (video: MVideo) {
     if (this.isHLS()) return this.getHLSFileStaticPath(video)
 
-    return this.getWebTorrentFileStaticPath(video)
+    return this.getWebVideoFileStaticPath(video)
   }
 
-  private getWebTorrentFileStaticPath (video: MVideo) {
+  private getWebVideoFileStaticPath (video: MVideo) {
     if (isVideoInPrivateDirectory(video.privacy)) {
-      return join(STATIC_PATHS.PRIVATE_WEBSEED, this.filename)
+      return join(STATIC_PATHS.PRIVATE_WEB_VIDEOS, this.filename)
     }
 
-    return join(STATIC_PATHS.WEBSEED, this.filename)
+    return join(STATIC_PATHS.WEB_VIDEOS, this.filename)
   }
 
   private getHLSFileStaticPath (video: MVideo) {
diff --git a/server/models/video/video-password.ts b/server/models/video/video-password.ts
new file mode 100644
index 000000000..648366c3b
--- /dev/null
+++ b/server/models/video/video-password.ts
@@ -0,0 +1,137 @@
+import { AllowNull, BelongsTo, Column, CreatedAt, DefaultScope, ForeignKey, Is, Model, Table, UpdatedAt } from 'sequelize-typescript'
+import { VideoModel } from './video'
+import { AttributesOnly } from '@shared/typescript-utils'
+import { ResultList, VideoPassword } from '@shared/models'
+import { getSort, throwIfNotValid } from '../shared'
+import { FindOptions, Transaction } from 'sequelize'
+import { MVideoPassword } from '@server/types/models'
+import { isPasswordValid } from '@server/helpers/custom-validators/videos'
+import { pick } from '@shared/core-utils'
+
+@DefaultScope(() => ({
+  include: [
+    {
+      model: VideoModel.unscoped(),
+      required: true
+    }
+  ]
+}))
+@Table({
+  tableName: 'videoPassword',
+  indexes: [
+    {
+      fields: [ 'videoId', 'password' ],
+      unique: true
+    }
+  ]
+})
+export class VideoPasswordModel extends Model<Partial<AttributesOnly<VideoPasswordModel>>> {
+
+  @AllowNull(false)
+  @Is('VideoPassword', value => throwIfNotValid(value, isPasswordValid, 'videoPassword'))
+  @Column
+  password: string
+
+  @CreatedAt
+  createdAt: Date
+
+  @UpdatedAt
+  updatedAt: Date
+
+  @ForeignKey(() => VideoModel)
+  @Column
+  videoId: number
+
+  @BelongsTo(() => VideoModel, {
+    foreignKey: {
+      allowNull: false
+    },
+    onDelete: 'cascade'
+  })
+  Video: VideoModel
+
+  static async countByVideoId (videoId: number, t?: Transaction) {
+    const query: FindOptions = {
+      where: {
+        videoId
+      },
+      transaction: t
+    }
+
+    return VideoPasswordModel.count(query)
+  }
+
+  static async loadByIdAndVideo (options: { id: number, videoId: number, t?: Transaction }): Promise<MVideoPassword> {
+    const { id, videoId, t } = options
+    const query: FindOptions = {
+      where: {
+        id,
+        videoId
+      },
+      transaction: t
+    }
+
+    return VideoPasswordModel.findOne(query)
+  }
+
+  static async listPasswords (options: {
+    start: number
+    count: number
+    sort: string
+    videoId: number
+  }): Promise<ResultList<MVideoPassword>> {
+    const { start, count, sort, videoId } = options
+
+    const { count: total, rows: data } = await VideoPasswordModel.findAndCountAll({
+      where: { videoId },
+      order: getSort(sort),
+      offset: start,
+      limit: count
+    })
+
+    return { total, data }
+  }
+
+  static async addPasswords (passwords: string[], videoId: number, transaction?: Transaction): Promise<void> {
+    for (const password of passwords) {
+      await VideoPasswordModel.create({
+        password,
+        videoId
+      }, { transaction })
+    }
+  }
+
+  static async deleteAllPasswords (videoId: number, transaction?: Transaction) {
+    await VideoPasswordModel.destroy({
+      where: { videoId },
+      transaction
+    })
+  }
+
+  static async deletePassword (passwordId: number, transaction?: Transaction) {
+    await VideoPasswordModel.destroy({
+      where: { id: passwordId },
+      transaction
+    })
+  }
+
+  static async isACorrectPassword (options: {
+    videoId: number
+    password: string
+  }) {
+    const query = {
+      where: pick(options, [ 'videoId', 'password' ])
+    }
+    return VideoPasswordModel.findOne(query)
+  }
+
+  toFormattedJSON (): VideoPassword {
+    return {
+      id: this.id,
+      password: this.password,
+      videoId: this.videoId,
+      createdAt: this.createdAt,
+      updatedAt: this.updatedAt
+    }
+  }
+}
diff --git a/server/models/video/video-playlist-element.ts b/server/models/video/video-playlist-element.ts
index b832f9768..61ae6b9fe 100644
--- a/server/models/video/video-playlist-element.ts
+++ b/server/models/video/video-playlist-element.ts
@@ -336,7 +336,10 @@ export class VideoPlaylistElementModel extends Model<Partial<AttributesOnly<Vide
     // Internal video?
     if (video.privacy === VideoPrivacy.INTERNAL && accountId) return VideoPlaylistElementType.REGULAR
 
-    if (video.privacy === VideoPrivacy.PRIVATE || video.privacy === VideoPrivacy.INTERNAL) return VideoPlaylistElementType.PRIVATE
+    // Private, internal and password protected videos cannot be read without appropriate access (ownership, internal)
+    if (new Set([ VideoPrivacy.PRIVATE, VideoPrivacy.INTERNAL, VideoPrivacy.PASSWORD_PROTECTED ]).has(video.privacy)) {
+      return VideoPlaylistElementType.PRIVATE
+    }
 
     if (video.isBlacklisted() || video.isBlocked()) return VideoPlaylistElementType.UNAVAILABLE
 
diff --git a/server/models/video/video-playlist.ts b/server/models/video/video-playlist.ts
index faf4bea78..15999d409 100644
--- a/server/models/video/video-playlist.ts
+++ b/server/models/video/video-playlist.ts
@@ -32,7 +32,7 @@ import {
 import {
   ACTIVITY_PUB,
   CONSTRAINTS_FIELDS,
-  STATIC_PATHS,
+  LAZY_STATIC_PATHS,
   THUMBNAILS_SIZE,
   VIDEO_PLAYLIST_PRIVACIES,
   VIDEO_PLAYLIST_TYPES,
@@ -592,13 +592,13 @@ export class VideoPlaylistModel extends Model<Partial<AttributesOnly<VideoPlayli
   getThumbnailUrl () {
     if (!this.hasThumbnail()) return null
 
-    return WEBSERVER.URL + STATIC_PATHS.THUMBNAILS + this.Thumbnail.filename
+    return WEBSERVER.URL + LAZY_STATIC_PATHS.THUMBNAILS + this.Thumbnail.filename
   }
 
   getThumbnailStaticPath () {
     if (!this.hasThumbnail()) return null
 
-    return join(STATIC_PATHS.THUMBNAILS, this.Thumbnail.filename)
+    return join(LAZY_STATIC_PATHS.THUMBNAILS, this.Thumbnail.filename)
   }
 
   getWatchStaticPath () {
diff --git a/server/models/video/video.ts b/server/models/video/video.ts
index 8e3af62a4..4c6297243 100644
--- a/server/models/video/video.ts
+++ b/server/models/video/video.ts
@@ -29,7 +29,7 @@ import {
 import { getPrivaciesForFederation, isPrivacyForFederation, isStateForFederation } from '@server/helpers/video'
 import { InternalEventEmitter } from '@server/lib/internal-event-emitter'
 import { LiveManager } from '@server/lib/live/live-manager'
-import { removeHLSFileObjectStorageByFilename, removeHLSObjectStorage, removeWebTorrentObjectStorage } from '@server/lib/object-storage'
+import { removeHLSFileObjectStorageByFilename, removeHLSObjectStorage, removeWebVideoObjectStorage } from '@server/lib/object-storage'
 import { tracer } from '@server/lib/opentelemetry/tracing'
 import { getHLSDirectory, getHLSRedundancyDirectory, getHlsResolutionPlaylistFilename } from '@server/lib/paths'
 import { Hooks } from '@server/lib/plugins/hooks'
@@ -58,7 +58,7 @@ import {
 import { AttributesOnly } from '@shared/typescript-utils'
 import { peertubeTruncate } from '../../helpers/core-utils'
 import { isActivityPubUrlValid } from '../../helpers/custom-validators/activitypub/misc'
-import { exists, isBooleanValid, isUUIDValid } from '../../helpers/custom-validators/misc'
+import { exists, isArray, isBooleanValid, isUUIDValid } from '../../helpers/custom-validators/misc'
 import {
   isVideoDescriptionValid,
   isVideoDurationValid,
@@ -75,6 +75,7 @@ import {
   MChannel,
   MChannelAccountDefault,
   MChannelId,
+  MStoryboard,
   MStreamingPlaylist,
   MStreamingPlaylistFilesVideo,
   MUserAccountId,
@@ -83,6 +84,8 @@ import {
   MVideoAccountLight,
   MVideoAccountLightBlacklistAllFiles,
   MVideoAP,
+  MVideoAPLight,
+  MVideoCaptionLanguageUrl,
   MVideoDetails,
   MVideoFileVideo,
   MVideoFormattable,
@@ -111,13 +114,13 @@ import { buildTrigramSearchIndex, buildWhereIdOrUUID, getVideoSort, isOutdated,
 import { UserModel } from '../user/user'
 import { UserVideoHistoryModel } from '../user/user-video-history'
 import { VideoViewModel } from '../view/video-view'
+import { videoModelToActivityPubObject } from './formatter/video-activity-pub-format'
 import {
   videoFilesModelToFormattedJSON,
   VideoFormattingJSONOptions,
-  videoModelToActivityPubObject,
   videoModelToFormattedDetailsJSON,
   videoModelToFormattedJSON
-} from './formatter/video-format-utils'
+} from './formatter/video-api-format'
 import { ScheduleVideoUpdateModel } from './schedule-video-update'
 import {
   BuildVideosListQueryOptions,
@@ -126,6 +129,7 @@ import {
   VideosIdListQueryBuilder,
   VideosModelListQueryBuilder
 } from './sql/video'
+import { StoryboardModel } from './storyboard'
 import { TagModel } from './tag'
 import { ThumbnailModel } from './thumbnail'
 import { VideoBlacklistModel } from './video-blacklist'
@@ -136,6 +140,7 @@ import { VideoFileModel } from './video-file'
 import { VideoImportModel } from './video-import'
 import { VideoJobInfoModel } from './video-job-info'
 import { VideoLiveModel } from './video-live'
+import { VideoPasswordModel } from './video-password'
 import { VideoPlaylistElementModel } from './video-playlist-element'
 import { VideoShareModel } from './video-share'
 import { VideoSourceModel } from './video-source'
@@ -146,7 +151,7 @@ export enum ScopeNames {
   FOR_API = 'FOR_API',
   WITH_ACCOUNT_DETAILS = 'WITH_ACCOUNT_DETAILS',
   WITH_TAGS = 'WITH_TAGS',
-  WITH_WEBTORRENT_FILES = 'WITH_WEBTORRENT_FILES',
+  WITH_WEB_VIDEO_FILES = 'WITH_WEB_VIDEO_FILES',
   WITH_SCHEDULED_UPDATE = 'WITH_SCHEDULED_UPDATE',
   WITH_BLACKLISTED = 'WITH_BLACKLISTED',
   WITH_STREAMING_PLAYLISTS = 'WITH_STREAMING_PLAYLISTS',
@@ -285,7 +290,7 @@ export type ForAPIOptions = {
       }
     ]
   },
-  [ScopeNames.WITH_WEBTORRENT_FILES]: (withRedundancies = false) => {
+  [ScopeNames.WITH_WEB_VIDEO_FILES]: (withRedundancies = false) => {
     let subInclude: any[] = []
 
     if (withRedundancies === true) {
@@ -734,6 +739,15 @@ export class VideoModel extends Model<Partial<AttributesOnly<VideoModel>>> {
   })
   VideoCaptions: VideoCaptionModel[]
 
+  @HasMany(() => VideoPasswordModel, {
+    foreignKey: {
+      name: 'videoId',
+      allowNull: false
+    },
+    onDelete: 'cascade'
+  })
+  VideoPasswords: VideoPasswordModel[]
+
   @HasOne(() => VideoJobInfoModel, {
     foreignKey: {
       name: 'videoId',
@@ -743,6 +757,16 @@ export class VideoModel extends Model<Partial<AttributesOnly<VideoModel>>> {
   })
   VideoJobInfo: VideoJobInfoModel
 
+  @HasOne(() => StoryboardModel, {
+    foreignKey: {
+      name: 'videoId',
+      allowNull: false
+    },
+    onDelete: 'cascade',
+    hooks: true
+  })
+  Storyboard: StoryboardModel
+
   @AfterCreate
   static notifyCreate (video: MVideo) {
     InternalEventEmitter.Instance.emit('video-created', { video })
@@ -789,7 +813,7 @@ export class VideoModel extends Model<Partial<AttributesOnly<VideoModel>>> {
 
       // Remove physical files and torrents
       instance.VideoFiles.forEach(file => {
-        tasks.push(instance.removeWebTorrentFile(file))
+        tasks.push(instance.removeWebVideoFile(file))
       })
 
       // Remove playlists file
@@ -894,6 +918,10 @@ export class VideoModel extends Model<Partial<AttributesOnly<VideoModel>>> {
           required: false
         },
         {
+          model: StoryboardModel.unscoped(),
+          required: false
+        },
+        {
           attributes: [ 'id', 'url' ],
           model: VideoShareModel.unscoped(),
           required: false,
@@ -1079,7 +1107,10 @@ export class VideoModel extends Model<Partial<AttributesOnly<VideoModel>>> {
     include?: VideoInclude
 
     hasFiles?: boolean // default false
-    hasWebtorrentFiles?: boolean
+
+    hasWebtorrentFiles?: boolean // TODO: remove in v7
+    hasWebVideoFiles?: boolean
+
     hasHLSFiles?: boolean
 
     categoryOneOf?: number[]
@@ -1144,6 +1175,7 @@ export class VideoModel extends Model<Partial<AttributesOnly<VideoModel>>> {
         'historyOfUser',
         'hasHLSFiles',
         'hasWebtorrentFiles',
+        'hasWebVideoFiles',
         'search',
         'excludeAlreadyWatched'
       ]),
@@ -1177,7 +1209,9 @@ export class VideoModel extends Model<Partial<AttributesOnly<VideoModel>>> {
 
     user?: MUserAccountId
 
-    hasWebtorrentFiles?: boolean
+    hasWebtorrentFiles?: boolean // TODO: remove in v7
+    hasWebVideoFiles?: boolean
+
     hasHLSFiles?: boolean
 
     search?: string
@@ -1224,6 +1258,7 @@ export class VideoModel extends Model<Partial<AttributesOnly<VideoModel>>> {
         'durationMax',
         'hasHLSFiles',
         'hasWebtorrentFiles',
+        'hasWebVideoFiles',
         'uuids',
         'search',
         'displayOnlyForFollower',
@@ -1648,7 +1683,7 @@ export class VideoModel extends Model<Partial<AttributesOnly<VideoModel>>> {
     return this.getQualityFileBy(minBy)
   }
 
-  getWebTorrentFile<T extends MVideoWithFile> (this: T, resolution: number): MVideoFileVideo {
+  getWebVideoFile<T extends MVideoWithFile> (this: T, resolution: number): MVideoFileVideo {
     if (Array.isArray(this.VideoFiles) === false) return undefined
 
     const file = this.VideoFiles.find(f => f.resolution === resolution)
@@ -1657,7 +1692,7 @@ export class VideoModel extends Model<Partial<AttributesOnly<VideoModel>>> {
     return Object.assign(file, { Video: this })
   }
 
-  hasWebTorrentFiles () {
+  hasWebVideoFiles () {
     return Array.isArray(this.VideoFiles) === true && this.VideoFiles.length !== 0
   }
 
@@ -1758,6 +1793,32 @@ export class VideoModel extends Model<Partial<AttributesOnly<VideoModel>>> {
     )
   }
 
+  async lightAPToFullAP (this: MVideoAPLight, transaction: Transaction): Promise<MVideoAP> {
+    const videoAP = this as MVideoAP
+
+    const getCaptions = () => {
+      if (isArray(videoAP.VideoCaptions)) return videoAP.VideoCaptions
+
+      return this.$get('VideoCaptions', {
+        attributes: [ 'filename', 'language', 'fileUrl' ],
+        transaction
+      }) as Promise<MVideoCaptionLanguageUrl[]>
+    }
+
+    const getStoryboard = () => {
+      if (videoAP.Storyboard) return videoAP.Storyboard
+
+      return this.$get('Storyboard', { transaction }) as Promise<MStoryboard>
+    }
+
+    const [ captions, storyboard ] = await Promise.all([ getCaptions(), getStoryboard() ])
+
+    return Object.assign(this, {
+      VideoCaptions: captions,
+      Storyboard: storyboard
+    })
+  }
+
   getTruncatedDescription () {
     if (!this.description) return null
 
@@ -1830,7 +1891,7 @@ export class VideoModel extends Model<Partial<AttributesOnly<VideoModel>>> {
                                        .concat(toAdd)
   }
 
-  removeWebTorrentFile (videoFile: MVideoFile, isRedundancy = false) {
+  removeWebVideoFile (videoFile: MVideoFile, isRedundancy = false) {
     const filePath = isRedundancy
       ? VideoPathManager.Instance.getFSRedundancyVideoFilePath(this, videoFile)
       : VideoPathManager.Instance.getFSVideoFileOutputPath(this, videoFile)
@@ -1839,7 +1900,7 @@ export class VideoModel extends Model<Partial<AttributesOnly<VideoModel>>> {
     if (!isRedundancy) promises.push(videoFile.removeTorrent())
 
     if (videoFile.storage === VideoStorage.OBJECT_STORAGE) {
-      promises.push(removeWebTorrentObjectStorage(videoFile))
+      promises.push(removeWebVideoObjectStorage(videoFile))
     }
 
     return Promise.all(promises)
@@ -1918,7 +1979,7 @@ export class VideoModel extends Model<Partial<AttributesOnly<VideoModel>>> {
 
   // ---------------------------------------------------------------------------
 
-  requiresAuth (options: {
+  requiresUserAuth (options: {
     urlParamId: string
     checkBlacklist: boolean
   }) {
@@ -1936,11 +1997,11 @@ export class VideoModel extends Model<Partial<AttributesOnly<VideoModel>>> {
 
     if (checkBlacklist && this.VideoBlacklist) return true
 
-    if (this.privacy !== VideoPrivacy.PUBLIC) {
-      throw new Error(`Unknown video privacy ${this.privacy} to know if the video requires auth`)
+    if (this.privacy === VideoPrivacy.PUBLIC || this.privacy === VideoPrivacy.PASSWORD_PROTECTED) {
+      return false
     }
 
-    return false
+    throw new Error(`Unknown video privacy ${this.privacy} to know if the video requires auth`)
   }
 
   hasPrivateStaticPath () {
@@ -1962,7 +2023,7 @@ export class VideoModel extends Model<Partial<AttributesOnly<VideoModel>>> {
   }
 
   getBandwidthBits (this: MVideo, videoFile: MVideoFile) {
-    if (!this.duration) throw new Error(`Cannot get bandwidth bits because video ${this.url} has duration of 0`)
+    if (!this.duration) return videoFile.size
 
     return Math.ceil((videoFile.size * 8) / this.duration)
   }
diff --git a/server/tests/api/check-params/config.ts b/server/tests/api/check-params/config.ts
index 472cad182..80b616ccf 100644
--- a/server/tests/api/check-params/config.ts
+++ b/server/tests/api/check-params/config.ts
@@ -74,6 +74,9 @@ describe('Test config API validators', function () {
       },
       torrents: {
         size: 4
+      },
+      storyboards: {
+        size: 5
       }
     },
     signup: {
@@ -123,7 +126,7 @@ describe('Test config API validators', function () {
         '2160p': false
       },
       alwaysTranscodeOriginalResolution: false,
-      webtorrent: {
+      webVideos: {
         enabled: true
       },
       hls: {
@@ -342,7 +345,7 @@ describe('Test config API validators', function () {
       })
     })
 
-    it('Should fail with a disabled webtorrent & hls transcoding', async function () {
+    it('Should fail with a disabled web videos & hls transcoding', async function () {
       const newUpdateParams = {
         ...updateParams,
 
@@ -350,7 +353,7 @@ describe('Test config API validators', function () {
           hls: {
             enabled: false
           },
-          webtorrent: {
+          web_videos: {
             enabled: false
           }
         }
diff --git a/server/tests/api/check-params/index.ts b/server/tests/api/check-params/index.ts
index 400d312d3..c2a7ccd78 100644
--- a/server/tests/api/check-params/index.ts
+++ b/server/tests/api/check-params/index.ts
@@ -34,6 +34,7 @@ import './video-comments'
 import './video-files'
 import './video-imports'
 import './video-playlists'
+import './video-storyboards'
 import './video-source'
 import './video-studio'
 import './video-token'
diff --git a/server/tests/api/check-params/live.ts b/server/tests/api/check-params/live.ts
index 2dc735c23..5021db516 100644
--- a/server/tests/api/check-params/live.ts
+++ b/server/tests/api/check-params/live.ts
@@ -143,7 +143,7 @@ describe('Test video lives API validator', function () {
     })
 
     it('Should fail with a bad privacy for replay settings', async function () {
-      const fields = { ...baseCorrectParams, replaySettings: { privacy: 5 } }
+      const fields = { ...baseCorrectParams, saveReplay: true, replaySettings: { privacy: 999 } }
 
       await makePostBodyRequest({ url: server.url, path, token: server.accessToken, fields })
     })
@@ -194,7 +194,7 @@ describe('Test video lives API validator', function () {
     it('Should fail with a big thumbnail file', async function () {
       const fields = baseCorrectParams
       const attaches = {
-        thumbnailfile: buildAbsoluteFixturePath('preview-big.png')
+        thumbnailfile: buildAbsoluteFixturePath('custom-preview-big.png')
       }
 
       await makeUploadRequest({ url: server.url, path, token: server.accessToken, fields, attaches })
@@ -212,7 +212,7 @@ describe('Test video lives API validator', function () {
     it('Should fail with a big preview file', async function () {
       const fields = baseCorrectParams
       const attaches = {
-        previewfile: buildAbsoluteFixturePath('preview-big.png')
+        previewfile: buildAbsoluteFixturePath('custom-preview-big.png')
       }
 
       await makeUploadRequest({ url: server.url, path, token: server.accessToken, fields, attaches })
@@ -472,7 +472,7 @@ describe('Test video lives API validator', function () {
     })
 
     it('Should fail with a bad privacy for replay settings', async function () {
-      const fields = { saveReplay: true, replaySettings: { privacy: 5 } }
+      const fields = { saveReplay: true, replaySettings: { privacy: 999 } }
 
       await command.update({ videoId: video.id, fields, expectedStatus: HttpStatusCode.BAD_REQUEST_400 })
     })
diff --git a/server/tests/api/check-params/runners.ts b/server/tests/api/check-params/runners.ts
index 48821b678..4ba90802f 100644
--- a/server/tests/api/check-params/runners.ts
+++ b/server/tests/api/check-params/runners.ts
@@ -752,7 +752,7 @@ describe('Test managing runners', function () {
         })
 
         it('Should fail with an invalid vod audio merge payload', async function () {
-          const attributes = { name: 'audio_with_preview', previewfile: 'preview.jpg', fixture: 'sample.ogg' }
+          const attributes = { name: 'audio_with_preview', previewfile: 'custom-preview.jpg', fixture: 'sample.ogg' }
           await server.videos.upload({ attributes, mode: 'legacy' })
 
           await waitJobs([ server ])
diff --git a/server/tests/api/check-params/transcoding.ts b/server/tests/api/check-params/transcoding.ts
index 9846ac182..4bebcb528 100644
--- a/server/tests/api/check-params/transcoding.ts
+++ b/server/tests/api/check-params/transcoding.ts
@@ -49,21 +49,21 @@ describe('Test transcoding API validators', function () {
 
   it('Should not run transcoding of a unknown video', async function () {
     await servers[0].videos.runTranscoding({ videoId: 404, transcodingType: 'hls', expectedStatus: HttpStatusCode.NOT_FOUND_404 })
-    await servers[0].videos.runTranscoding({ videoId: 404, transcodingType: 'webtorrent', expectedStatus: HttpStatusCode.NOT_FOUND_404 })
+    await servers[0].videos.runTranscoding({ videoId: 404, transcodingType: 'web-video', expectedStatus: HttpStatusCode.NOT_FOUND_404 })
   })
 
   it('Should not run transcoding of a remote video', async function () {
     const expectedStatus = HttpStatusCode.BAD_REQUEST_400
 
     await servers[0].videos.runTranscoding({ videoId: remoteId, transcodingType: 'hls', expectedStatus })
-    await servers[0].videos.runTranscoding({ videoId: remoteId, transcodingType: 'webtorrent', expectedStatus })
+    await servers[0].videos.runTranscoding({ videoId: remoteId, transcodingType: 'web-video', expectedStatus })
   })
 
   it('Should not run transcoding by a non admin user', async function () {
     const expectedStatus = HttpStatusCode.FORBIDDEN_403
 
     await servers[0].videos.runTranscoding({ videoId: validId, transcodingType: 'hls', token: userToken, expectedStatus })
-    await servers[0].videos.runTranscoding({ videoId: validId, transcodingType: 'webtorrent', token: moderatorToken, expectedStatus })
+    await servers[0].videos.runTranscoding({ videoId: validId, transcodingType: 'web-video', token: moderatorToken, expectedStatus })
   })
 
   it('Should not run transcoding without transcoding type', async function () {
@@ -82,7 +82,7 @@ describe('Test transcoding API validators', function () {
     await servers[0].config.disableTranscoding()
 
     await servers[0].videos.runTranscoding({ videoId: validId, transcodingType: 'hls', expectedStatus })
-    await servers[0].videos.runTranscoding({ videoId: validId, transcodingType: 'webtorrent', expectedStatus })
+    await servers[0].videos.runTranscoding({ videoId: validId, transcodingType: 'web-video', expectedStatus })
   })
 
   it('Should run transcoding', async function () {
@@ -93,15 +93,15 @@ describe('Test transcoding API validators', function () {
     await servers[0].videos.runTranscoding({ videoId: validId, transcodingType: 'hls' })
     await waitJobs(servers)
 
-    await servers[0].videos.runTranscoding({ videoId: validId, transcodingType: 'webtorrent' })
+    await servers[0].videos.runTranscoding({ videoId: validId, transcodingType: 'web-video' })
     await waitJobs(servers)
   })
 
   it('Should not run transcoding on a video that is already being transcoded', async function () {
-    await servers[0].videos.runTranscoding({ videoId: validId, transcodingType: 'webtorrent' })
+    await servers[0].videos.runTranscoding({ videoId: validId, transcodingType: 'web-video' })
 
     const expectedStatus = HttpStatusCode.CONFLICT_409
-    await servers[0].videos.runTranscoding({ videoId: validId, transcodingType: 'webtorrent', expectedStatus })
+    await servers[0].videos.runTranscoding({ videoId: validId, transcodingType: 'web-video', expectedStatus })
   })
 
   after(async function () {
diff --git a/server/tests/api/check-params/video-files.ts b/server/tests/api/check-params/video-files.ts
index 9dc59a1b5..4d43ab6f8 100644
--- a/server/tests/api/check-params/video-files.ts
+++ b/server/tests/api/check-params/video-files.ts
@@ -60,7 +60,7 @@ describe('Test videos files', function () {
   })
 
   describe('Deleting files', function () {
-    let webtorrentId: string
+    let webVideoId: string
     let hlsId: string
     let remoteId: string
 
@@ -68,10 +68,10 @@ describe('Test videos files', function () {
     let validId2: string
 
     let hlsFileId: number
-    let webtorrentFileId: number
+    let webVideoFileId: number
 
     let remoteHLSFileId: number
-    let remoteWebtorrentFileId: number
+    let remoteWebVideoFileId: number
 
     before(async function () {
       this.timeout(300_000)
@@ -83,7 +83,7 @@ describe('Test videos files', function () {
         const video = await servers[1].videos.get({ id: uuid })
         remoteId = video.uuid
         remoteHLSFileId = video.streamingPlaylists[0].files[0].id
-        remoteWebtorrentFileId = video.files[0].id
+        remoteWebVideoFileId = video.files[0].id
       }
 
       {
@@ -96,7 +96,7 @@ describe('Test videos files', function () {
           const video = await servers[0].videos.get({ id: uuid })
           validId1 = video.uuid
           hlsFileId = video.streamingPlaylists[0].files[0].id
-          webtorrentFileId = video.files[0].id
+          webVideoFileId = video.files[0].id
         }
 
         {
@@ -117,8 +117,8 @@ describe('Test videos files', function () {
 
       {
         await servers[0].config.enableTranscoding(false, true)
-        const { uuid } = await servers[0].videos.quickUpload({ name: 'webtorrent' })
-        webtorrentId = uuid
+        const { uuid } = await servers[0].videos.quickUpload({ name: 'web-video' })
+        webVideoId = uuid
       }
 
       await waitJobs(servers)
@@ -128,27 +128,27 @@ describe('Test videos files', function () {
       const expectedStatus = HttpStatusCode.NOT_FOUND_404
 
       await servers[0].videos.removeHLSPlaylist({ videoId: 404, expectedStatus })
-      await servers[0].videos.removeAllWebTorrentFiles({ videoId: 404, expectedStatus })
+      await servers[0].videos.removeAllWebVideoFiles({ videoId: 404, expectedStatus })
 
       await servers[0].videos.removeHLSFile({ videoId: 404, fileId: hlsFileId, expectedStatus })
-      await servers[0].videos.removeWebTorrentFile({ videoId: 404, fileId: webtorrentFileId, expectedStatus })
+      await servers[0].videos.removeWebVideoFile({ videoId: 404, fileId: webVideoFileId, expectedStatus })
     })
 
     it('Should not delete unknown files', async function () {
       const expectedStatus = HttpStatusCode.NOT_FOUND_404
 
-      await servers[0].videos.removeHLSFile({ videoId: validId1, fileId: webtorrentFileId, expectedStatus })
-      await servers[0].videos.removeWebTorrentFile({ videoId: validId1, fileId: hlsFileId, expectedStatus })
+      await servers[0].videos.removeHLSFile({ videoId: validId1, fileId: webVideoFileId, expectedStatus })
+      await servers[0].videos.removeWebVideoFile({ videoId: validId1, fileId: hlsFileId, expectedStatus })
     })
 
     it('Should not delete files of a remote video', async function () {
       const expectedStatus = HttpStatusCode.BAD_REQUEST_400
 
       await servers[0].videos.removeHLSPlaylist({ videoId: remoteId, expectedStatus })
-      await servers[0].videos.removeAllWebTorrentFiles({ videoId: remoteId, expectedStatus })
+      await servers[0].videos.removeAllWebVideoFiles({ videoId: remoteId, expectedStatus })
 
       await servers[0].videos.removeHLSFile({ videoId: remoteId, fileId: remoteHLSFileId, expectedStatus })
-      await servers[0].videos.removeWebTorrentFile({ videoId: remoteId, fileId: remoteWebtorrentFileId, expectedStatus })
+      await servers[0].videos.removeWebVideoFile({ videoId: remoteId, fileId: remoteWebVideoFileId, expectedStatus })
     })
 
     it('Should not delete files by a non admin user', async function () {
@@ -157,35 +157,35 @@ describe('Test videos files', function () {
       await servers[0].videos.removeHLSPlaylist({ videoId: validId1, token: userToken, expectedStatus })
       await servers[0].videos.removeHLSPlaylist({ videoId: validId1, token: moderatorToken, expectedStatus })
 
-      await servers[0].videos.removeAllWebTorrentFiles({ videoId: validId1, token: userToken, expectedStatus })
-      await servers[0].videos.removeAllWebTorrentFiles({ videoId: validId1, token: moderatorToken, expectedStatus })
+      await servers[0].videos.removeAllWebVideoFiles({ videoId: validId1, token: userToken, expectedStatus })
+      await servers[0].videos.removeAllWebVideoFiles({ videoId: validId1, token: moderatorToken, expectedStatus })
 
       await servers[0].videos.removeHLSFile({ videoId: validId1, fileId: hlsFileId, token: userToken, expectedStatus })
       await servers[0].videos.removeHLSFile({ videoId: validId1, fileId: hlsFileId, token: moderatorToken, expectedStatus })
 
-      await servers[0].videos.removeWebTorrentFile({ videoId: validId1, fileId: webtorrentFileId, token: userToken, expectedStatus })
-      await servers[0].videos.removeWebTorrentFile({ videoId: validId1, fileId: webtorrentFileId, token: moderatorToken, expectedStatus })
+      await servers[0].videos.removeWebVideoFile({ videoId: validId1, fileId: webVideoFileId, token: userToken, expectedStatus })
+      await servers[0].videos.removeWebVideoFile({ videoId: validId1, fileId: webVideoFileId, token: moderatorToken, expectedStatus })
     })
 
     it('Should not delete files if the files are not available', async function () {
       await servers[0].videos.removeHLSPlaylist({ videoId: hlsId, expectedStatus: HttpStatusCode.BAD_REQUEST_400 })
-      await servers[0].videos.removeAllWebTorrentFiles({ videoId: webtorrentId, expectedStatus: HttpStatusCode.BAD_REQUEST_400 })
+      await servers[0].videos.removeAllWebVideoFiles({ videoId: webVideoId, expectedStatus: HttpStatusCode.BAD_REQUEST_400 })
 
       await servers[0].videos.removeHLSFile({ videoId: hlsId, fileId: 404, expectedStatus: HttpStatusCode.NOT_FOUND_404 })
-      await servers[0].videos.removeWebTorrentFile({ videoId: webtorrentId, fileId: 404, expectedStatus: HttpStatusCode.NOT_FOUND_404 })
+      await servers[0].videos.removeWebVideoFile({ videoId: webVideoId, fileId: 404, expectedStatus: HttpStatusCode.NOT_FOUND_404 })
     })
 
     it('Should not delete files if no both versions are available', async function () {
       await servers[0].videos.removeHLSPlaylist({ videoId: hlsId, expectedStatus: HttpStatusCode.BAD_REQUEST_400 })
-      await servers[0].videos.removeAllWebTorrentFiles({ videoId: webtorrentId, expectedStatus: HttpStatusCode.BAD_REQUEST_400 })
+      await servers[0].videos.removeAllWebVideoFiles({ videoId: webVideoId, expectedStatus: HttpStatusCode.BAD_REQUEST_400 })
     })
 
     it('Should delete files if both versions are available', async function () {
       await servers[0].videos.removeHLSFile({ videoId: validId1, fileId: hlsFileId })
-      await servers[0].videos.removeWebTorrentFile({ videoId: validId1, fileId: webtorrentFileId })
+      await servers[0].videos.removeWebVideoFile({ videoId: validId1, fileId: webVideoFileId })
 
       await servers[0].videos.removeHLSPlaylist({ videoId: validId1 })
-      await servers[0].videos.removeAllWebTorrentFiles({ videoId: validId2 })
+      await servers[0].videos.removeAllWebVideoFiles({ videoId: validId2 })
     })
   })
 
diff --git a/server/tests/api/check-params/video-imports.ts b/server/tests/api/check-params/video-imports.ts
index 7f19b9ee9..8c6f43c12 100644
--- a/server/tests/api/check-params/video-imports.ts
+++ b/server/tests/api/check-params/video-imports.ts
@@ -244,7 +244,7 @@ describe('Test video imports API validator', function () {
     it('Should fail with a big thumbnail file', async function () {
       const fields = baseCorrectParams
       const attaches = {
-        thumbnailfile: buildAbsoluteFixturePath('preview-big.png')
+        thumbnailfile: buildAbsoluteFixturePath('custom-preview-big.png')
       }
 
       await makeUploadRequest({ url: server.url, path, token: server.accessToken, fields, attaches })
@@ -262,7 +262,7 @@ describe('Test video imports API validator', function () {
     it('Should fail with a big preview file', async function () {
       const fields = baseCorrectParams
       const attaches = {
-        previewfile: buildAbsoluteFixturePath('preview-big.png')
+        previewfile: buildAbsoluteFixturePath('custom-preview-big.png')
       }
 
       await makeUploadRequest({ url: server.url, path, token: server.accessToken, fields, attaches })
diff --git a/server/tests/api/check-params/video-passwords.ts b/server/tests/api/check-params/video-passwords.ts
new file mode 100644
index 000000000..4e936b5d2
--- /dev/null
+++ b/server/tests/api/check-params/video-passwords.ts
@@ -0,0 +1,609 @@
+/* eslint-disable @typescript-eslint/no-unused-expressions,@typescript-eslint/require-await */
+import {
+  FIXTURE_URLS,
+  checkBadCountPagination,
+  checkBadSortPagination,
+  checkBadStartPagination,
+  checkUploadVideoParam
+} from '@server/tests/shared'
+import { root } from '@shared/core-utils'
+import {
+  HttpStatusCode,
+  PeerTubeProblemDocument,
+  ServerErrorCode,
+  VideoCreateResult,
+  VideoPrivacy
+} from '@shared/models'
+import {
+  cleanupTests,
+  createSingleServer,
+  makePostBodyRequest,
+  PeerTubeServer,
+  setAccessTokensToServers
+} from '@shared/server-commands'
+import { expect } from 'chai'
+import { join } from 'path'
+
+describe('Test video passwords validator', function () {
+  let path: string
+  let server: PeerTubeServer
+  let userAccessToken = ''
+  let video: VideoCreateResult
+  let channelId: number
+  let publicVideo: VideoCreateResult
+  let commentId: number
+  // ---------------------------------------------------------------
+
+  before(async function () {
+    this.timeout(50000)
+
+    server = await createSingleServer(1)
+
+    await setAccessTokensToServers([ server ])
+
+    await server.config.updateCustomSubConfig({
+      newConfig: {
+        live: {
+          enabled: true,
+          latencySetting: {
+            enabled: false
+          },
+          allowReplay: false
+        },
+        import: {
+          videos: {
+            http:{
+              enabled: true
+            }
+          }
+        }
+      }
+    })
+
+    userAccessToken = await server.users.generateUserAndToken('user1')
+
+    {
+      const body = await server.users.getMyInfo()
+      channelId = body.videoChannels[0].id
+    }
+
+    {
+      video = await server.videos.quickUpload({
+        name: 'password protected video',
+        privacy: VideoPrivacy.PASSWORD_PROTECTED,
+        videoPasswords: [ 'password1', 'password2' ]
+      })
+    }
+    path = '/api/v1/videos/'
+  })
+
+  async function checkVideoPasswordOptions (options: {
+    server: PeerTubeServer
+    token: string
+    videoPasswords: string[]
+    expectedStatus: HttpStatusCode
+    mode: 'uploadLegacy' | 'uploadResumable' | 'import' | 'updateVideo' | 'updatePasswords' | 'live'
+  }) {
+    const { server, token, videoPasswords, expectedStatus = HttpStatusCode.OK_200, mode } = options
+    const attaches = {
+      fixture: join(root(), 'server', 'tests', 'fixtures', 'video_short.webm')
+    }
+    const baseCorrectParams = {
+      name: 'my super name',
+      category: 5,
+      licence: 1,
+      language: 'pt',
+      nsfw: false,
+      commentsEnabled: true,
+      downloadEnabled: true,
+      waitTranscoding: true,
+      description: 'my super description',
+      support: 'my super support text',
+      tags: [ 'tag1', 'tag2' ],
+      privacy: VideoPrivacy.PASSWORD_PROTECTED,
+      channelId,
+      originallyPublishedAt: new Date().toISOString()
+    }
+    if (mode === 'uploadLegacy') {
+      const fields = { ...baseCorrectParams, videoPasswords }
+      return checkUploadVideoParam(server, token, { ...fields, ...attaches }, expectedStatus, 'legacy')
+    }
+
+    if (mode === 'uploadResumable') {
+      const fields = { ...baseCorrectParams, videoPasswords }
+      return checkUploadVideoParam(server, token, { ...fields, ...attaches }, expectedStatus, 'resumable')
+    }
+
+    if (mode === 'import') {
+      const attributes = { ...baseCorrectParams, targetUrl: FIXTURE_URLS.goodVideo, videoPasswords }
+      return server.imports.importVideo({ attributes, expectedStatus })
+    }
+
+    if (mode === 'updateVideo') {
+      const attributes = { ...baseCorrectParams, videoPasswords }
+      return server.videos.update({ token, expectedStatus, id: video.id, attributes })
+    }
+
+    if (mode === 'updatePasswords') {
+      return server.videoPasswords.updateAll({ token, expectedStatus, videoId: video.id, passwords: videoPasswords })
+    }
+
+    if (mode === 'live') {
+      const fields = { ...baseCorrectParams, videoPasswords }
+
+      return server.live.create({ fields, expectedStatus })
+    }
+  }
+
+  function validateVideoPasswordList (mode: 'uploadLegacy' | 'uploadResumable' | 'import' | 'updateVideo' | 'updatePasswords' | 'live') {
+
+    it('Should fail with a password protected privacy without providing a password', async function () {
+      await checkVideoPasswordOptions({
+        server,
+        token: server.accessToken,
+        videoPasswords: undefined,
+        expectedStatus: HttpStatusCode.BAD_REQUEST_400,
+        mode
+      })
+    })
+
+    it('Should fail with a password protected privacy and an empty password list', async function () {
+      const videoPasswords = []
+
+      await checkVideoPasswordOptions({
+        server,
+        token: server.accessToken,
+        videoPasswords,
+        expectedStatus: HttpStatusCode.BAD_REQUEST_400,
+        mode
+      })
+    })
+
+    it('Should fail with a password protected privacy and a too short password', async function () {
+      const videoPasswords = [ 'p' ]
+
+      await checkVideoPasswordOptions({
+        server,
+        token: server.accessToken,
+        videoPasswords,
+        expectedStatus: HttpStatusCode.BAD_REQUEST_400,
+        mode
+      })
+    })
+
+    it('Should fail with a password protected privacy and a too long password', async function () {
+      const videoPasswords = [ 'Very very very very very very very very very very very very very very very very very very long password' ]
+
+      await checkVideoPasswordOptions({
+        server,
+        token: server.accessToken,
+        videoPasswords,
+        expectedStatus: HttpStatusCode.BAD_REQUEST_400,
+        mode
+      })
+    })
+
+    it('Should fail with a password protected privacy and an empty password', async function () {
+      const videoPasswords = [ '' ]
+
+      await checkVideoPasswordOptions({
+        server,
+        token: server.accessToken,
+        videoPasswords,
+        expectedStatus: HttpStatusCode.BAD_REQUEST_400,
+        mode
+      })
+    })
+
+    it('Should fail with a password protected privacy and duplicated passwords', async function () {
+      const videoPasswords = [ 'password', 'password' ]
+
+      await checkVideoPasswordOptions({
+        server,
+        token: server.accessToken,
+        videoPasswords,
+        expectedStatus: HttpStatusCode.BAD_REQUEST_400,
+        mode
+      })
+    })
+
+    if (mode === 'updatePasswords') {
+      it('Should fail for an unauthenticated user', async function () {
+        const videoPasswords = [ 'password' ]
+        await checkVideoPasswordOptions({
+          server,
+          token: null,
+          videoPasswords,
+          expectedStatus: HttpStatusCode.UNAUTHORIZED_401,
+          mode
+        })
+      })
+
+      it('Should fail for an unauthorized user', async function () {
+        const videoPasswords = [ 'password' ]
+        await checkVideoPasswordOptions({
+          server,
+          token: userAccessToken,
+          videoPasswords,
+          expectedStatus: HttpStatusCode.FORBIDDEN_403,
+          mode
+        })
+      })
+    }
+
+    it('Should succeed with a password protected privacy and correct passwords', async function () {
+      const videoPasswords = [ 'password1', 'password2' ]
+      const expectedStatus = mode === 'updatePasswords' || mode === 'updateVideo'
+        ? HttpStatusCode.NO_CONTENT_204
+        : HttpStatusCode.OK_200
+
+      await checkVideoPasswordOptions({ server, token: server.accessToken, videoPasswords, expectedStatus, mode })
+    })
+  }
+
+  describe('When adding or updating a video', function () {
+    describe('Resumable upload', function () {
+      validateVideoPasswordList('uploadResumable')
+    })
+
+    describe('Legacy upload', function () {
+      validateVideoPasswordList('uploadLegacy')
+    })
+
+    describe('When importing a video', function () {
+      validateVideoPasswordList('import')
+    })
+
+    describe('When updating a video', function () {
+      validateVideoPasswordList('updateVideo')
+    })
+
+    describe('When updating the password list of a video', function () {
+      validateVideoPasswordList('updatePasswords')
+    })
+
+    describe('When creating a live', function () {
+      validateVideoPasswordList('live')
+    })
+  })
+
+  async function checkVideoAccessOptions (options: {
+    server: PeerTubeServer
+    token?: string
+    videoPassword?: string
+    expectedStatus: HttpStatusCode
+    mode: 'get' | 'getWithPassword' | 'getWithToken' | 'listCaptions' | 'createThread' | 'listThreads' | 'replyThread' | 'rate' | 'token'
+  }) {
+    const { server, token = null, videoPassword, expectedStatus, mode } = options
+
+    if (mode === 'get') {
+      return server.videos.get({ id: video.id, expectedStatus })
+    }
+
+    if (mode === 'getWithToken') {
+      return server.videos.getWithToken({
+        id: video.id,
+        token,
+        expectedStatus
+      })
+    }
+
+    if (mode === 'getWithPassword') {
+      return server.videos.getWithPassword({
+        id: video.id,
+        token,
+        expectedStatus,
+        password: videoPassword
+      })
+    }
+
+    if (mode === 'rate') {
+      return server.videos.rate({
+        id: video.id,
+        token,
+        expectedStatus,
+        rating: 'like',
+        videoPassword
+      })
+    }
+
+    if (mode === 'createThread') {
+      const fields = { text: 'super comment' }
+      const headers = videoPassword !== undefined && videoPassword !== null
+        ? { 'x-peertube-video-password': videoPassword }
+        : undefined
+      const body = await makePostBodyRequest({
+        url: server.url,
+        path: path + video.uuid + '/comment-threads',
+        token,
+        fields,
+        headers,
+        expectedStatus
+      })
+      return JSON.parse(body.text)
+    }
+
+    if (mode === 'replyThread') {
+      const fields = { text: 'super reply' }
+      const headers = videoPassword !== undefined && videoPassword !== null
+        ? { 'x-peertube-video-password': videoPassword }
+        : undefined
+      return makePostBodyRequest({
+        url: server.url,
+        path: path + video.uuid + '/comments/' + commentId,
+        token,
+        fields,
+        headers,
+        expectedStatus
+      })
+    }
+    if (mode === 'listThreads') {
+      return server.comments.listThreads({
+        videoId: video.id,
+        token,
+        expectedStatus,
+        videoPassword
+      })
+    }
+
+    if (mode === 'listCaptions') {
+      return server.captions.list({
+        videoId: video.id,
+        token,
+        expectedStatus,
+        videoPassword
+      })
+    }
+
+    if (mode === 'token') {
+      return server.videoToken.create({
+        videoId: video.id,
+        token,
+        expectedStatus,
+        videoPassword
+      })
+    }
+  }
+
+  function checkVideoError (error: any, mode: 'providePassword' | 'incorrectPassword') {
+    const serverCode = mode === 'providePassword'
+      ? ServerErrorCode.VIDEO_REQUIRES_PASSWORD
+      : ServerErrorCode.INCORRECT_VIDEO_PASSWORD
+
+    const message = mode === 'providePassword'
+      ? 'Please provide a password to access this password protected video'
+      : 'Incorrect video password. Access to the video is denied.'
+
+    if (!error.code) {
+      error = JSON.parse(error.text)
+    }
+
+    expect(error.code).to.equal(serverCode)
+    expect(error.detail).to.equal(message)
+    expect(error.error).to.equal(message)
+
+    expect(error.status).to.equal(HttpStatusCode.FORBIDDEN_403)
+  }
+
+  function validateVideoAccess (mode: 'get' | 'listCaptions' | 'createThread' | 'listThreads' | 'replyThread' | 'rate' | 'token') {
+    const requiresUserAuth = [ 'createThread', 'replyThread', 'rate' ].includes(mode)
+    let tokens: string[]
+    if (!requiresUserAuth) {
+      it('Should fail without providing a password for an unlogged user', async function () {
+        const body = await checkVideoAccessOptions({ server, expectedStatus: HttpStatusCode.FORBIDDEN_403, mode })
+        const error = body as unknown as PeerTubeProblemDocument
+
+        checkVideoError(error, 'providePassword')
+      })
+    }
+
+    it('Should fail without providing a password for an unauthorised user', async function () {
+      const tmp = mode === 'get' ? 'getWithToken' : mode
+
+      const body = await checkVideoAccessOptions({
+        server,
+        token: userAccessToken,
+        expectedStatus: HttpStatusCode.FORBIDDEN_403,
+        mode: tmp
+      })
+
+      const error = body as unknown as PeerTubeProblemDocument
+
+      checkVideoError(error, 'providePassword')
+    })
+
+    it('Should fail if a wrong password is entered', async function () {
+      const tmp = mode === 'get' ? 'getWithPassword' : mode
+      tokens = [ userAccessToken, server.accessToken ]
+
+      if (!requiresUserAuth) tokens.push(null)
+
+      for (const token of tokens) {
+        const body = await checkVideoAccessOptions({
+          server,
+          token,
+          videoPassword: 'toto',
+          expectedStatus: HttpStatusCode.FORBIDDEN_403,
+          mode: tmp
+        })
+        const error = body as unknown as PeerTubeProblemDocument
+
+        checkVideoError(error, 'incorrectPassword')
+      }
+    })
+
+    it('Should fail if an empty password is entered', async function () {
+      const tmp = mode === 'get' ? 'getWithPassword' : mode
+
+      for (const token of tokens) {
+        const body = await checkVideoAccessOptions({
+          server,
+          token,
+          videoPassword: '',
+          expectedStatus: HttpStatusCode.FORBIDDEN_403,
+          mode: tmp
+        })
+        const error = body as unknown as PeerTubeProblemDocument
+
+        checkVideoError(error, 'incorrectPassword')
+      }
+    })
+
+    it('Should fail if an inccorect password containing the correct password is entered', async function () {
+      const tmp = mode === 'get' ? 'getWithPassword' : mode
+
+      for (const token of tokens) {
+        const body = await checkVideoAccessOptions({
+          server,
+          token,
+          videoPassword: 'password11',
+          expectedStatus: HttpStatusCode.FORBIDDEN_403,
+          mode: tmp
+        })
+        const error = body as unknown as PeerTubeProblemDocument
+
+        checkVideoError(error, 'incorrectPassword')
+      }
+    })
+
+    it('Should succeed without providing a password for an authorised user', async function () {
+      const tmp = mode === 'get' ? 'getWithToken' : mode
+      const expectedStatus = mode === 'rate' ? HttpStatusCode.NO_CONTENT_204 : HttpStatusCode.OK_200
+
+      const body = await checkVideoAccessOptions({ server, token: server.accessToken, expectedStatus, mode: tmp })
+
+      if (mode === 'createThread') commentId = body.comment.id
+    })
+
+    it('Should succeed using correct passwords', async function () {
+      const tmp = mode === 'get' ? 'getWithPassword' : mode
+      const expectedStatus = mode === 'rate' ? HttpStatusCode.NO_CONTENT_204 : HttpStatusCode.OK_200
+
+      for (const token of tokens) {
+        await checkVideoAccessOptions({ server, videoPassword: 'password1', token, expectedStatus, mode: tmp })
+        await checkVideoAccessOptions({ server, videoPassword: 'password2', token, expectedStatus, mode: tmp })
+      }
+    })
+  }
+
+  describe('When accessing password protected video', function () {
+
+    describe('For getting a password protected video', function () {
+      validateVideoAccess('get')
+    })
+
+    describe('For rating a video', function () {
+      validateVideoAccess('rate')
+    })
+
+    describe('For creating a thread', function () {
+      validateVideoAccess('createThread')
+    })
+
+    describe('For replying to a thread', function () {
+      validateVideoAccess('replyThread')
+    })
+
+    describe('For listing threads', function () {
+      validateVideoAccess('listThreads')
+    })
+
+    describe('For getting captions', function () {
+      validateVideoAccess('listCaptions')
+    })
+
+    describe('For creating video file token', function () {
+      validateVideoAccess('token')
+    })
+  })
+
+  describe('When listing passwords', function () {
+    it('Should fail with a bad start pagination', async function () {
+      await checkBadStartPagination(server.url, path + video.uuid + '/passwords', server.accessToken)
+    })
+
+    it('Should fail with a bad count pagination', async function () {
+      await checkBadCountPagination(server.url, path + video.uuid + '/passwords', server.accessToken)
+    })
+
+    it('Should fail with an incorrect sort', async function () {
+      await checkBadSortPagination(server.url, path + video.uuid + '/passwords', server.accessToken)
+    })
+
+    it('Should fail for unauthenticated user', async function () {
+      await server.videoPasswords.list({
+        token: null,
+        expectedStatus: HttpStatusCode.UNAUTHORIZED_401,
+        videoId: video.id
+      })
+    })
+
+    it('Should fail for unauthorized user', async function () {
+      await server.videoPasswords.list({
+        token: userAccessToken,
+        expectedStatus: HttpStatusCode.FORBIDDEN_403,
+        videoId: video.id
+      })
+    })
+
+    it('Should succeed with the correct parameters', async function () {
+      await server.videoPasswords.list({
+        token: server.accessToken,
+        expectedStatus: HttpStatusCode.OK_200,
+        videoId: video.id
+      })
+    })
+  })
+
+  describe('When deleting a password', async function () {
+    const passwords = (await server.videoPasswords.list({ videoId: video.id })).data
+
+    it('Should fail with wrong password id', async function () {
+      await server.videoPasswords.remove({ id: -1, videoId: video.id, expectedStatus: HttpStatusCode.NOT_FOUND_404 })
+    })
+
+    it('Should fail for unauthenticated user', async function () {
+      await server.videoPasswords.remove({
+        id: passwords[0].id,
+        token: null,
+        videoId: video.id,
+        expectedStatus: HttpStatusCode.FORBIDDEN_403
+      })
+    })
+
+    it('Should fail for unauthorized user', async function () {
+      await server.videoPasswords.remove({
+        id: passwords[0].id,
+        token: userAccessToken,
+        videoId: video.id,
+        expectedStatus: HttpStatusCode.BAD_REQUEST_400
+      })
+    })
+
+    it('Should fail for non password protected video', async function () {
+      publicVideo = await server.videos.quickUpload({ name: 'public video' })
+      await server.videoPasswords.remove({ id: passwords[0].id, videoId: publicVideo.id, expectedStatus: HttpStatusCode.BAD_REQUEST_400 })
+    })
+
+    it('Should fail for password not linked to correct video', async function () {
+      const video2 = await server.videos.quickUpload({
+        name: 'password protected video',
+        privacy: VideoPrivacy.PASSWORD_PROTECTED,
+        videoPasswords: [ 'password1', 'password2' ]
+      })
+      await server.videoPasswords.remove({ id: passwords[0].id, videoId: video2.id, expectedStatus: HttpStatusCode.NOT_FOUND_404 })
+    })
+
+    it('Should succeed with correct parameter', async function () {
+      await server.videoPasswords.remove({ id: passwords[0].id, videoId: video.id, expectedStatus: HttpStatusCode.NO_CONTENT_204 })
+    })
+
+    it('Should fail for last password of a video', async function () {
+      await server.videoPasswords.remove({ id: passwords[1].id, videoId: video.id, expectedStatus: HttpStatusCode.BAD_REQUEST_400 })
+    })
+  })
+
+  after(async function () {
+    await cleanupTests([ server ])
+  })
+})
diff --git a/server/tests/api/check-params/video-playlists.ts b/server/tests/api/check-params/video-playlists.ts
index 8090897c1..8c3233e0b 100644
--- a/server/tests/api/check-params/video-playlists.ts
+++ b/server/tests/api/check-params/video-playlists.ts
@@ -196,7 +196,7 @@ describe('Test video playlists API validator', function () {
         attributes: {
           displayName: 'display name',
           privacy: VideoPlaylistPrivacy.UNLISTED,
-          thumbnailfile: 'thumbnail.jpg',
+          thumbnailfile: 'custom-thumbnail.jpg',
           videoChannelId: server.store.channel.id,
 
           ...attributes
@@ -260,7 +260,7 @@ describe('Test video playlists API validator', function () {
     })
 
     it('Should fail with a thumbnail file too big', async function () {
-      const params = getBase({ thumbnailfile: 'preview-big.png' })
+      const params = getBase({ thumbnailfile: 'custom-preview-big.png' })
 
       await command.create(params)
       await command.update(getUpdate(params, playlist.shortUUID))
diff --git a/server/tests/api/check-params/video-storyboards.ts b/server/tests/api/check-params/video-storyboards.ts
new file mode 100644
index 000000000..c038e7370
--- /dev/null
+++ b/server/tests/api/check-params/video-storyboards.ts
@@ -0,0 +1,45 @@
+/* eslint-disable @typescript-eslint/no-unused-expressions,@typescript-eslint/require-await */
+
+import { HttpStatusCode, VideoPrivacy } from '@shared/models'
+import { cleanupTests, createSingleServer, PeerTubeServer, setAccessTokensToServers } from '@shared/server-commands'
+
+describe('Test video storyboards API validator', function () {
+  let server: PeerTubeServer
+
+  let publicVideo: { uuid: string }
+  let privateVideo: { uuid: string }
+
+  // ---------------------------------------------------------------
+
+  before(async function () {
+    this.timeout(120000)
+
+    server = await createSingleServer(1)
+    await setAccessTokensToServers([ server ])
+
+    publicVideo = await server.videos.quickUpload({ name: 'public' })
+    privateVideo = await server.videos.quickUpload({ name: 'private', privacy: VideoPrivacy.PRIVATE })
+  })
+
+  it('Should fail without a valid uuid', async function () {
+    await server.storyboard.list({ id: '4da6fde3-88f7-4d16-b119-108df563d0b0', expectedStatus: HttpStatusCode.NOT_FOUND_404 })
+  })
+
+  it('Should receive 404 when passing a non existing video id', async function () {
+    await server.storyboard.list({ id: '4da6fde3-88f7-4d16-b119-108df5630b06', expectedStatus: HttpStatusCode.NOT_FOUND_404 })
+  })
+
+  it('Should not get the private storyboard without the appropriate token', async function () {
+    await server.storyboard.list({ id: privateVideo.uuid, expectedStatus: HttpStatusCode.UNAUTHORIZED_401, token: null })
+    await server.storyboard.list({ id: publicVideo.uuid, expectedStatus: HttpStatusCode.OK_200, token: null })
+  })
+
+  it('Should succeed with the correct parameters', async function () {
+    await server.storyboard.list({ id: privateVideo.uuid })
+    await server.storyboard.list({ id: publicVideo.uuid })
+  })
+
+  after(async function () {
+    await cleanupTests([ server ])
+  })
+})
diff --git a/server/tests/api/check-params/video-studio.ts b/server/tests/api/check-params/video-studio.ts
index add8d9164..4ac0d93ed 100644
--- a/server/tests/api/check-params/video-studio.ts
+++ b/server/tests/api/check-params/video-studio.ts
@@ -293,7 +293,7 @@ describe('Test video studio API validator', function () {
       it('Should succeed with the correct params', async function () {
         this.timeout(120000)
 
-        await addWatermark('thumbnail.jpg', HttpStatusCode.NO_CONTENT_204)
+        await addWatermark('custom-thumbnail.jpg', HttpStatusCode.NO_CONTENT_204)
 
         await waitJobs([ server ])
       })
@@ -322,8 +322,8 @@ describe('Test video studio API validator', function () {
       })
 
       it('Should fail with an invalid file', async function () {
-        await addIntroOutro('add-intro', 'thumbnail.jpg')
-        await addIntroOutro('add-outro', 'thumbnail.jpg')
+        await addIntroOutro('add-intro', 'custom-thumbnail.jpg')
+        await addIntroOutro('add-outro', 'custom-thumbnail.jpg')
       })
 
       it('Should fail with a file that does not contain video stream', async function () {
diff --git a/server/tests/api/check-params/video-token.ts b/server/tests/api/check-params/video-token.ts
index 7acb9d580..7cb3e84a2 100644
--- a/server/tests/api/check-params/video-token.ts
+++ b/server/tests/api/check-params/video-token.ts
@@ -5,9 +5,12 @@ import { cleanupTests, createSingleServer, PeerTubeServer, setAccessTokensToServ
 
 describe('Test video tokens', function () {
   let server: PeerTubeServer
-  let videoId: string
+  let privateVideoId: string
+  let passwordProtectedVideoId: string
   let userToken: string
 
+  const videoPassword = 'password'
+
   // ---------------------------------------------------------------
 
   before(async function () {
@@ -15,27 +18,50 @@ describe('Test video tokens', function () {
 
     server = await createSingleServer(1)
     await setAccessTokensToServers([ server ])
-
-    const { uuid } = await server.videos.quickUpload({ name: 'video', privacy: VideoPrivacy.PRIVATE })
-    videoId = uuid
-
+    {
+      const { uuid } = await server.videos.quickUpload({ name: 'private video', privacy: VideoPrivacy.PRIVATE })
+      privateVideoId = uuid
+    }
+    {
+      const { uuid } = await server.videos.quickUpload({
+        name: 'password protected video',
+        privacy: VideoPrivacy.PASSWORD_PROTECTED,
+        videoPasswords: [ videoPassword ]
+      })
+      passwordProtectedVideoId = uuid
+    }
     userToken = await server.users.generateUserAndToken('user1')
   })
 
-  it('Should not generate tokens for unauthenticated user', async function () {
-    await server.videoToken.create({ videoId, token: null, expectedStatus: HttpStatusCode.UNAUTHORIZED_401 })
+  it('Should not generate tokens on private video for unauthenticated user', async function () {
+    await server.videoToken.create({ videoId: privateVideoId, token: null, expectedStatus: HttpStatusCode.UNAUTHORIZED_401 })
   })
 
   it('Should not generate tokens of unknown video', async function () {
     await server.videoToken.create({ videoId: 404, expectedStatus: HttpStatusCode.NOT_FOUND_404 })
   })
 
+  it('Should not generate tokens with incorrect password', async function () {
+    await server.videoToken.create({
+      videoId: passwordProtectedVideoId,
+      token: null,
+      expectedStatus: HttpStatusCode.FORBIDDEN_403,
+      videoPassword: 'incorrectPassword'
+    })
+  })
+
   it('Should not generate tokens of a non owned video', async function () {
-    await server.videoToken.create({ videoId, token: userToken, expectedStatus: HttpStatusCode.FORBIDDEN_403 })
+    await server.videoToken.create({ videoId: privateVideoId, token: userToken, expectedStatus: HttpStatusCode.FORBIDDEN_403 })
   })
 
   it('Should generate token', async function () {
-    await server.videoToken.create({ videoId })
+    await server.videoToken.create({ videoId: privateVideoId })
+  })
+
+  it('Should generate token on password protected video', async function () {
+    await server.videoToken.create({ videoId: passwordProtectedVideoId, videoPassword, token: null })
+    await server.videoToken.create({ videoId: passwordProtectedVideoId, videoPassword, token: userToken })
+    await server.videoToken.create({ videoId: passwordProtectedVideoId, videoPassword })
   })
 
   after(async function () {
diff --git a/server/tests/api/check-params/videos-overviews.ts b/server/tests/api/check-params/videos-overviews.ts
index f9cdb7ab3..ae7de24dd 100644
--- a/server/tests/api/check-params/videos-overviews.ts
+++ b/server/tests/api/check-params/videos-overviews.ts
@@ -2,7 +2,7 @@
 
 import { cleanupTests, createSingleServer, PeerTubeServer } from '@shared/server-commands'
 
-describe('Test videos overview', function () {
+describe('Test videos overview API validator', function () {
   let server: PeerTubeServer
 
   // ---------------------------------------------------------------
diff --git a/server/tests/api/check-params/videos.ts b/server/tests/api/check-params/videos.ts
index 094ab6891..6ee1955a7 100644
--- a/server/tests/api/check-params/videos.ts
+++ b/server/tests/api/check-params/videos.ts
@@ -384,7 +384,7 @@ describe('Test videos API validator', function () {
       it('Should fail with a big thumbnail file', async function () {
         const fields = baseCorrectParams
         const attaches = {
-          thumbnailfile: join(root(), 'server', 'tests', 'fixtures', 'preview-big.png'),
+          thumbnailfile: join(root(), 'server', 'tests', 'fixtures', 'custom-preview-big.png'),
           fixture: join(root(), 'server', 'tests', 'fixtures', 'video_short.mp4')
         }
 
@@ -404,7 +404,7 @@ describe('Test videos API validator', function () {
       it('Should fail with a big preview file', async function () {
         const fields = baseCorrectParams
         const attaches = {
-          previewfile: join(root(), 'server', 'tests', 'fixtures', 'preview-big.png'),
+          previewfile: join(root(), 'server', 'tests', 'fixtures', 'custom-preview-big.png'),
           fixture: join(root(), 'server', 'tests', 'fixtures', 'video_short.mp4')
         }
 
@@ -615,7 +615,7 @@ describe('Test videos API validator', function () {
     it('Should fail with a big thumbnail file', async function () {
       const fields = baseCorrectParams
       const attaches = {
-        thumbnailfile: join(root(), 'server', 'tests', 'fixtures', 'preview-big.png')
+        thumbnailfile: join(root(), 'server', 'tests', 'fixtures', 'custom-preview-big.png')
       }
 
       await makeUploadRequest({
@@ -647,7 +647,7 @@ describe('Test videos API validator', function () {
     it('Should fail with a big preview file', async function () {
       const fields = baseCorrectParams
       const attaches = {
-        previewfile: join(root(), 'server', 'tests', 'fixtures', 'preview-big.png')
+        previewfile: join(root(), 'server', 'tests', 'fixtures', 'custom-preview-big.png')
       }
 
       await makeUploadRequest({
diff --git a/server/tests/api/live/live.ts b/server/tests/api/live/live.ts
index 7ab67b126..2b302a8a2 100644
--- a/server/tests/api/live/live.ts
+++ b/server/tests/api/live/live.ts
@@ -2,7 +2,7 @@
 
 import { expect } from 'chai'
 import { basename, join } from 'path'
-import { SQLCommand, testImage, testLiveVideoResolutions } from '@server/tests/shared'
+import { SQLCommand, testImageGeneratedByFFmpeg, testLiveVideoResolutions } from '@server/tests/shared'
 import { getAllFiles, wait } from '@shared/core-utils'
 import { ffprobePromise, getVideoStream } from '@shared/ffmpeg'
 import {
@@ -121,8 +121,8 @@ describe('Test live', function () {
         expect(video.downloadEnabled).to.be.false
         expect(video.privacy.id).to.equal(VideoPrivacy.PUBLIC)
 
-        await testImage(server.url, 'video_short1-preview.webm', video.previewPath)
-        await testImage(server.url, 'video_short1.webm', video.thumbnailPath)
+        await testImageGeneratedByFFmpeg(server.url, 'video_short1-preview.webm', video.previewPath)
+        await testImageGeneratedByFFmpeg(server.url, 'video_short1.webm', video.thumbnailPath)
 
         const live = await server.live.get({ videoId: liveVideoUUID })
 
diff --git a/server/tests/api/object-storage/video-static-file-privacy.ts b/server/tests/api/object-storage/video-static-file-privacy.ts
index af9d681b2..64ab542a5 100644
--- a/server/tests/api/object-storage/video-static-file-privacy.ts
+++ b/server/tests/api/object-storage/video-static-file-privacy.ts
@@ -39,7 +39,7 @@ describe('Object storage for video static file privacy', function () {
     const video = await server.videos.getWithToken({ id: uuid })
 
     for (const file of video.files) {
-      expectStartWith(file.fileUrl, server.url + '/object-storage-proxy/webseed/private/')
+      expectStartWith(file.fileUrl, server.url + '/object-storage-proxy/web-videos/private/')
 
       await makeRawRequest({ url: file.fileUrl, token: server.accessToken, expectedStatus: HttpStatusCode.OK_200 })
     }
@@ -107,15 +107,20 @@ describe('Object storage for video static file privacy', function () {
   describe('VOD', function () {
     let privateVideoUUID: string
     let publicVideoUUID: string
+    let passwordProtectedVideoUUID: string
     let userPrivateVideoUUID: string
 
+    const correctPassword = 'my super password'
+    const correctPasswordHeader = { 'x-peertube-video-password': correctPassword }
+    const incorrectPasswordHeader = { 'x-peertube-video-password': correctPassword + 'toto' }
+
     // ---------------------------------------------------------------------------
 
     async function getSampleFileUrls (videoId: string) {
       const video = await server.videos.getWithToken({ id: videoId })
 
       return {
-        webTorrentFile: video.files[0].fileUrl,
+        webVideoFile: video.files[0].fileUrl,
         hlsFile: getHLS(video).files[0].fileUrl
       }
     }
@@ -140,6 +145,22 @@ describe('Object storage for video static file privacy', function () {
       await checkPrivateVODFiles(privateVideoUUID)
     })
 
+    it('Should upload a password protected video and have appropriate object storage ACL', async function () {
+      this.timeout(120000)
+
+      {
+        const { uuid } = await server.videos.quickUpload({
+          name: 'video',
+          privacy: VideoPrivacy.PASSWORD_PROTECTED,
+          videoPasswords: [ correctPassword ]
+        })
+        passwordProtectedVideoUUID = uuid
+      }
+      await waitJobs([ server ])
+
+      await checkPrivateVODFiles(passwordProtectedVideoUUID)
+    })
+
     it('Should upload a public video and have appropriate object storage ACL', async function () {
       this.timeout(120000)
 
@@ -154,13 +175,49 @@ describe('Object storage for video static file privacy', function () {
     it('Should not get files without appropriate OAuth token', async function () {
       this.timeout(60000)
 
-      const { webTorrentFile, hlsFile } = await getSampleFileUrls(privateVideoUUID)
+      const { webVideoFile, hlsFile } = await getSampleFileUrls(privateVideoUUID)
+
+      await makeRawRequest({ url: webVideoFile, token: userToken, expectedStatus: HttpStatusCode.FORBIDDEN_403 })
+      await makeRawRequest({ url: webVideoFile, token: server.accessToken, expectedStatus: HttpStatusCode.OK_200 })
+
+      await makeRawRequest({ url: hlsFile, token: userToken, expectedStatus: HttpStatusCode.FORBIDDEN_403 })
+      await makeRawRequest({ url: hlsFile, token: server.accessToken, expectedStatus: HttpStatusCode.OK_200 })
+    })
+
+    it('Should not get files without appropriate password or appropriate OAuth token', async function () {
+      this.timeout(60000)
+
+      const { webVideoFile, hlsFile } = await getSampleFileUrls(passwordProtectedVideoUUID)
 
-      await makeRawRequest({ url: webTorrentFile, token: userToken, expectedStatus: HttpStatusCode.FORBIDDEN_403 })
-      await makeRawRequest({ url: webTorrentFile, token: server.accessToken, expectedStatus: HttpStatusCode.OK_200 })
+      await makeRawRequest({ url: webVideoFile, token: userToken, expectedStatus: HttpStatusCode.FORBIDDEN_403 })
+      await makeRawRequest({
+        url: webVideoFile,
+        token: null,
+        headers: incorrectPasswordHeader,
+        expectedStatus: HttpStatusCode.FORBIDDEN_403
+      })
+      await makeRawRequest({ url: webVideoFile, token: server.accessToken, expectedStatus: HttpStatusCode.OK_200 })
+      await makeRawRequest({
+        url: webVideoFile,
+        token: null,
+        headers: correctPasswordHeader,
+        expectedStatus: HttpStatusCode.OK_200
+      })
 
       await makeRawRequest({ url: hlsFile, token: userToken, expectedStatus: HttpStatusCode.FORBIDDEN_403 })
+      await makeRawRequest({
+        url: hlsFile,
+        token: null,
+        headers: incorrectPasswordHeader,
+        expectedStatus: HttpStatusCode.FORBIDDEN_403
+      })
       await makeRawRequest({ url: hlsFile, token: server.accessToken, expectedStatus: HttpStatusCode.OK_200 })
+      await makeRawRequest({
+        url: hlsFile,
+        token: null,
+        headers: correctPasswordHeader,
+        expectedStatus: HttpStatusCode.OK_200
+      })
     })
 
     it('Should not get HLS file of another video', async function () {
@@ -176,21 +233,50 @@ describe('Object storage for video static file privacy', function () {
       await makeRawRequest({ url: goodUrl, token: server.accessToken, expectedStatus: HttpStatusCode.OK_200 })
     })
 
-    it('Should correctly check OAuth or video file token', async function () {
+    it('Should correctly check OAuth, video file token of private video', async function () {
       this.timeout(60000)
 
       const badVideoFileToken = await server.videoToken.getVideoFileToken({ token: userToken, videoId: userPrivateVideoUUID })
       const goodVideoFileToken = await server.videoToken.getVideoFileToken({ videoId: privateVideoUUID })
 
-      const { webTorrentFile, hlsFile } = await getSampleFileUrls(privateVideoUUID)
+      const { webVideoFile, hlsFile } = await getSampleFileUrls(privateVideoUUID)
+
+      for (const url of [ webVideoFile, hlsFile ]) {
+        await makeRawRequest({ url, expectedStatus: HttpStatusCode.FORBIDDEN_403 })
+        await makeRawRequest({ url, token: userToken, expectedStatus: HttpStatusCode.FORBIDDEN_403 })
+        await makeRawRequest({ url, token: server.accessToken, expectedStatus: HttpStatusCode.OK_200 })
+
+        await makeRawRequest({ url, query: { videoFileToken: badVideoFileToken }, expectedStatus: HttpStatusCode.FORBIDDEN_403 })
+        await makeRawRequest({ url, query: { videoFileToken: goodVideoFileToken }, expectedStatus: HttpStatusCode.OK_200 })
+
+      }
+    })
+
+    it('Should correctly check OAuth, video file token or video password of password protected video', async function () {
+      this.timeout(60000)
 
-      for (const url of [ webTorrentFile, hlsFile ]) {
+      const badVideoFileToken = await server.videoToken.getVideoFileToken({ token: userToken, videoId: userPrivateVideoUUID })
+      const goodVideoFileToken = await server.videoToken.getVideoFileToken({
+        videoId: passwordProtectedVideoUUID,
+        videoPassword: correctPassword
+      })
+
+      const { webVideoFile, hlsFile } = await getSampleFileUrls(passwordProtectedVideoUUID)
+
+      for (const url of [ hlsFile, webVideoFile ]) {
         await makeRawRequest({ url, expectedStatus: HttpStatusCode.FORBIDDEN_403 })
         await makeRawRequest({ url, token: userToken, expectedStatus: HttpStatusCode.FORBIDDEN_403 })
         await makeRawRequest({ url, token: server.accessToken, expectedStatus: HttpStatusCode.OK_200 })
 
         await makeRawRequest({ url, query: { videoFileToken: badVideoFileToken }, expectedStatus: HttpStatusCode.FORBIDDEN_403 })
         await makeRawRequest({ url, query: { videoFileToken: goodVideoFileToken }, expectedStatus: HttpStatusCode.OK_200 })
+
+        await makeRawRequest({
+          url,
+          headers: incorrectPasswordHeader,
+          expectedStatus: HttpStatusCode.FORBIDDEN_403
+        })
+        await makeRawRequest({ url, headers: correctPasswordHeader, expectedStatus: HttpStatusCode.OK_200 })
       }
     })
 
@@ -232,16 +318,26 @@ describe('Object storage for video static file privacy', function () {
     let permanentLiveId: string
     let permanentLive: LiveVideo
 
+    let passwordProtectedLiveId: string
+    let passwordProtectedLive: LiveVideo
+
+    const correctPassword = 'my super password'
+
     let unrelatedFileToken: string
 
     // ---------------------------------------------------------------------------
 
-    async function checkLiveFiles (live: LiveVideo, liveId: string) {
+    async function checkLiveFiles (live: LiveVideo, liveId: string, videoPassword?: string) {
       const ffmpegCommand = sendRTMPStream({ rtmpBaseUrl: live.rtmpUrl, streamKey: live.streamKey })
       await server.live.waitUntilPublished({ videoId: liveId })
 
-      const video = await server.videos.getWithToken({ id: liveId })
-      const fileToken = await server.videoToken.getVideoFileToken({ videoId: video.uuid })
+      const video = videoPassword
+        ? await server.videos.getWithPassword({ id: liveId, password: videoPassword })
+        : await server.videos.getWithToken({ id: liveId })
+
+      const fileToken = videoPassword
+        ? await server.videoToken.getVideoFileToken({ token: null, videoId: video.uuid, videoPassword })
+        : await server.videoToken.getVideoFileToken({ videoId: video.uuid })
 
       const hls = video.streamingPlaylists[0]
 
@@ -253,10 +349,19 @@ describe('Object storage for video static file privacy', function () {
 
         await makeRawRequest({ url, token: server.accessToken, expectedStatus: HttpStatusCode.OK_200 })
         await makeRawRequest({ url, query: { videoFileToken: fileToken }, expectedStatus: HttpStatusCode.OK_200 })
-
+        if (videoPassword) {
+          await makeRawRequest({ url, headers: { 'x-peertube-video-password': videoPassword }, expectedStatus: HttpStatusCode.OK_200 })
+        }
         await makeRawRequest({ url, token: userToken, expectedStatus: HttpStatusCode.FORBIDDEN_403 })
         await makeRawRequest({ url, expectedStatus: HttpStatusCode.FORBIDDEN_403 })
         await makeRawRequest({ url, query: { videoFileToken: unrelatedFileToken }, expectedStatus: HttpStatusCode.FORBIDDEN_403 })
+        if (videoPassword) {
+          await makeRawRequest({
+            url,
+            headers: { 'x-peertube-video-password': 'incorrectPassword' },
+            expectedStatus: HttpStatusCode.FORBIDDEN_403
+          })
+        }
       }
 
       await stopFfmpeg(ffmpegCommand)
@@ -326,6 +431,17 @@ describe('Object storage for video static file privacy', function () {
         permanentLiveId = video.uuid
         permanentLive = live
       }
+
+      {
+        const { video, live } = await server.live.quickCreate({
+          saveReplay: false,
+          permanentLive: false,
+          privacy: VideoPrivacy.PASSWORD_PROTECTED,
+          videoPasswords: [ correctPassword ]
+        })
+        passwordProtectedLiveId = video.uuid
+        passwordProtectedLive = live
+      }
     })
 
     it('Should create a private normal live and have a private static path', async function () {
@@ -340,6 +456,12 @@ describe('Object storage for video static file privacy', function () {
       await checkLiveFiles(permanentLive, permanentLiveId)
     })
 
+    it('Should create a password protected live and have a private static path', async function () {
+      this.timeout(240000)
+
+      await checkLiveFiles(passwordProtectedLive, passwordProtectedLiveId, correctPassword)
+    })
+
     it('Should reinject video file token in permanent live', async function () {
       this.timeout(240000)
 
@@ -412,11 +534,11 @@ describe('Object storage for video static file privacy', function () {
 
     it('Should not be able to access object storage proxy', async function () {
       const privateVideo = await server.videos.getWithToken({ id: videoUUID })
-      const webtorrentFilename = extractFilenameFromUrl(privateVideo.files[0].fileUrl)
+      const webVideoFilename = extractFilenameFromUrl(privateVideo.files[0].fileUrl)
       const hlsFilename = extractFilenameFromUrl(getHLS(privateVideo).files[0].fileUrl)
 
       await makeRawRequest({
-        url: server.url + '/object-storage-proxy/webseed/private/' + webtorrentFilename,
+        url: server.url + '/object-storage-proxy/web-videos/private/' + webVideoFilename,
         token: server.accessToken,
         expectedStatus: HttpStatusCode.BAD_REQUEST_400
       })
diff --git a/server/tests/api/object-storage/videos.ts b/server/tests/api/object-storage/videos.ts
index f837d9966..dcc52ef06 100644
--- a/server/tests/api/object-storage/videos.ts
+++ b/server/tests/api/object-storage/videos.ts
@@ -41,8 +41,8 @@ async function checkFiles (options: {
   playlistBucket: string
   playlistPrefix?: string
 
-  webtorrentBucket: string
-  webtorrentPrefix?: string
+  webVideoBucket: string
+  webVideoPrefix?: string
 }) {
   const {
     server,
@@ -50,20 +50,20 @@ async function checkFiles (options: {
     originSQLCommand,
     video,
     playlistBucket,
-    webtorrentBucket,
+    webVideoBucket,
     baseMockUrl,
     playlistPrefix,
-    webtorrentPrefix
+    webVideoPrefix
   } = options
 
   let allFiles = video.files
 
   for (const file of video.files) {
     const baseUrl = baseMockUrl
-      ? `${baseMockUrl}/${webtorrentBucket}/`
-      : `http://${webtorrentBucket}.${ObjectStorageCommand.getMockEndpointHost()}/`
+      ? `${baseMockUrl}/${webVideoBucket}/`
+      : `http://${webVideoBucket}.${ObjectStorageCommand.getMockEndpointHost()}/`
 
-    const prefix = webtorrentPrefix || ''
+    const prefix = webVideoPrefix || ''
     const start = baseUrl + prefix
 
     expectStartWith(file.fileUrl, start)
@@ -134,8 +134,8 @@ function runTestSuite (options: {
   playlistBucket: string
   playlistPrefix?: string
 
-  webtorrentBucket: string
-  webtorrentPrefix?: string
+  webVideoBucket: string
+  webVideoPrefix?: string
 
   useMockBaseUrl?: boolean
 }) {
@@ -161,7 +161,7 @@ function runTestSuite (options: {
       : undefined
 
     await objectStorage.createMockBucket(options.playlistBucket)
-    await objectStorage.createMockBucket(options.webtorrentBucket)
+    await objectStorage.createMockBucket(options.webVideoBucket)
 
     const config = {
       object_storage: {
@@ -181,11 +181,11 @@ function runTestSuite (options: {
             : undefined
         },
 
-        videos: {
-          bucket_name: options.webtorrentBucket,
-          prefix: options.webtorrentPrefix,
+        web_videos: {
+          bucket_name: options.webVideoBucket,
+          prefix: options.webVideoPrefix,
           base_url: baseMockUrl
-            ? `${baseMockUrl}/${options.webtorrentBucket}`
+            ? `${baseMockUrl}/${options.webVideoBucket}`
             : undefined
         }
       }
@@ -308,7 +308,7 @@ describe('Object storage for videos', function () {
             bucket_name: 'aaa'
           },
 
-          videos: {
+          web_videos: {
             bucket_name: 'aaa'
           }
         }
@@ -386,27 +386,27 @@ describe('Object storage for videos', function () {
   describe('Test simple object storage', function () {
     runTestSuite({
       playlistBucket: objectStorage.getMockBucketName('streaming-playlists'),
-      webtorrentBucket: objectStorage.getMockBucketName('videos')
+      webVideoBucket: objectStorage.getMockBucketName('web-videos')
     })
   })
 
   describe('Test object storage with prefix', function () {
     runTestSuite({
       playlistBucket: objectStorage.getMockBucketName('mybucket'),
-      webtorrentBucket: objectStorage.getMockBucketName('mybucket'),
+      webVideoBucket: objectStorage.getMockBucketName('mybucket'),
 
       playlistPrefix: 'streaming-playlists_',
-      webtorrentPrefix: 'webtorrent_'
+      webVideoPrefix: 'webvideo_'
     })
   })
 
   describe('Test object storage with prefix and base URL', function () {
     runTestSuite({
       playlistBucket: objectStorage.getMockBucketName('mybucket'),
-      webtorrentBucket: objectStorage.getMockBucketName('mybucket'),
+      webVideoBucket: objectStorage.getMockBucketName('mybucket'),
 
       playlistPrefix: 'streaming-playlists/',
-      webtorrentPrefix: 'webtorrent/',
+      webVideoPrefix: 'webvideo/',
 
       useMockBaseUrl: true
     })
@@ -431,7 +431,7 @@ describe('Object storage for videos', function () {
     runTestSuite({
       maxUploadPart,
       playlistBucket: objectStorage.getMockBucketName('streaming-playlists'),
-      webtorrentBucket: objectStorage.getMockBucketName('videos'),
+      webVideoBucket: objectStorage.getMockBucketName('web-videos'),
       fixture
     })
   })
diff --git a/server/tests/api/redundancy/redundancy.ts b/server/tests/api/redundancy/redundancy.ts
index 5262c503f..0c5c27225 100644
--- a/server/tests/api/redundancy/redundancy.ts
+++ b/server/tests/api/redundancy/redundancy.ts
@@ -43,7 +43,7 @@ async function checkMagnetWebseeds (file: VideoFile, baseWebseeds: string[], ser
   }
 }
 
-async function createServers (strategy: VideoRedundancyStrategy | null, additionalParams: any = {}, withWebtorrent = true) {
+async function createServers (strategy: VideoRedundancyStrategy | null, additionalParams: any = {}, withWebVideo = true) {
   const strategies: any[] = []
 
   if (strategy !== null) {
@@ -60,8 +60,8 @@ async function createServers (strategy: VideoRedundancyStrategy | null, addition
 
   const config = {
     transcoding: {
-      webtorrent: {
-        enabled: withWebtorrent
+      web_videos: {
+        enabled: withWebVideo
       },
       hls: {
         enabled: true
@@ -100,7 +100,7 @@ async function createServers (strategy: VideoRedundancyStrategy | null, addition
 }
 
 async function ensureSameFilenames (videoUUID: string) {
-  let webtorrentFilenames: string[]
+  let webVideoFilenames: string[]
   let hlsFilenames: string[]
 
   for (const server of servers) {
@@ -108,24 +108,24 @@ async function ensureSameFilenames (videoUUID: string) {
 
     // Ensure we use the same filenames that the origin
 
-    const localWebtorrentFilenames = video.files.map(f => basename(f.fileUrl)).sort()
+    const localWebVideoFilenames = video.files.map(f => basename(f.fileUrl)).sort()
     const localHLSFilenames = video.streamingPlaylists[0].files.map(f => basename(f.fileUrl)).sort()
 
-    if (webtorrentFilenames) expect(webtorrentFilenames).to.deep.equal(localWebtorrentFilenames)
-    else webtorrentFilenames = localWebtorrentFilenames
+    if (webVideoFilenames) expect(webVideoFilenames).to.deep.equal(localWebVideoFilenames)
+    else webVideoFilenames = localWebVideoFilenames
 
     if (hlsFilenames) expect(hlsFilenames).to.deep.equal(localHLSFilenames)
     else hlsFilenames = localHLSFilenames
   }
 
-  return { webtorrentFilenames, hlsFilenames }
+  return { webVideoFilenames, hlsFilenames }
 }
 
 async function check1WebSeed (videoUUID?: string) {
   if (!videoUUID) videoUUID = video1Server2.uuid
 
   const webseeds = [
-    `${servers[1].url}/static/webseed/`
+    `${servers[1].url}/static/web-videos/`
   ]
 
   for (const server of servers) {
@@ -145,7 +145,7 @@ async function check2Webseeds (videoUUID?: string) {
 
   const webseeds = [
     `${servers[0].url}/static/redundancy/`,
-    `${servers[1].url}/static/webseed/`
+    `${servers[1].url}/static/web-videos/`
   ]
 
   for (const server of servers) {
@@ -156,11 +156,11 @@ async function check2Webseeds (videoUUID?: string) {
     }
   }
 
-  const { webtorrentFilenames } = await ensureSameFilenames(videoUUID)
+  const { webVideoFilenames } = await ensureSameFilenames(videoUUID)
 
   const directories = [
     servers[0].getDirectoryPath('redundancy'),
-    servers[1].getDirectoryPath('videos')
+    servers[1].getDirectoryPath('web-videos')
   ]
 
   for (const directory of directories) {
@@ -168,7 +168,7 @@ async function check2Webseeds (videoUUID?: string) {
     expect(files).to.have.length.at.least(4)
 
     // Ensure we files exist on disk
-    expect(files.find(f => webtorrentFilenames.includes(f))).to.exist
+    expect(files.find(f => webVideoFilenames.includes(f))).to.exist
   }
 }
 
diff --git a/server/tests/api/runners/runner-studio-transcoding.ts b/server/tests/api/runners/runner-studio-transcoding.ts
index 41c556775..443a9d02a 100644
--- a/server/tests/api/runners/runner-studio-transcoding.ts
+++ b/server/tests/api/runners/runner-studio-transcoding.ts
@@ -104,7 +104,7 @@ describe('Test runner video studio transcoding', function () {
       {
         name: 'add-watermark' as 'add-watermark',
         options: {
-          file: 'thumbnail.png'
+          file: 'custom-thumbnail.png'
         }
       },
       {
diff --git a/server/tests/api/runners/runner-vod-transcoding.ts b/server/tests/api/runners/runner-vod-transcoding.ts
index d9da0f40d..ca16d9c10 100644
--- a/server/tests/api/runners/runner-vod-transcoding.ts
+++ b/server/tests/api/runners/runner-vod-transcoding.ts
@@ -424,7 +424,7 @@ describe('Test runner VOD transcoding', function () {
 
       await servers[0].config.enableTranscoding(true, true)
 
-      const attributes = { name: 'audio_with_preview', previewfile: 'preview.jpg', fixture: 'sample.ogg' }
+      const attributes = { name: 'audio_with_preview', previewfile: 'custom-preview.jpg', fixture: 'sample.ogg' }
       const { uuid } = await servers[0].videos.upload({ attributes, mode: 'legacy' })
       videoUUID = uuid
 
diff --git a/server/tests/api/server/config.ts b/server/tests/api/server/config.ts
index 011ba268c..0e700eddb 100644
--- a/server/tests/api/server/config.ts
+++ b/server/tests/api/server/config.ts
@@ -46,6 +46,7 @@ function checkInitialConfig (server: PeerTubeServer, data: CustomConfig) {
   expect(data.cache.previews.size).to.equal(1)
   expect(data.cache.captions.size).to.equal(1)
   expect(data.cache.torrents.size).to.equal(1)
+  expect(data.cache.storyboards.size).to.equal(1)
 
   expect(data.signup.enabled).to.be.true
   expect(data.signup.limit).to.equal(4)
@@ -78,7 +79,7 @@ function checkInitialConfig (server: PeerTubeServer, data: CustomConfig) {
   expect(data.transcoding.resolutions['1440p']).to.be.true
   expect(data.transcoding.resolutions['2160p']).to.be.true
   expect(data.transcoding.alwaysTranscodeOriginalResolution).to.be.true
-  expect(data.transcoding.webtorrent.enabled).to.be.true
+  expect(data.transcoding.webVideos.enabled).to.be.true
   expect(data.transcoding.hls.enabled).to.be.true
 
   expect(data.live.enabled).to.be.false
@@ -154,6 +155,7 @@ function checkUpdatedConfig (data: CustomConfig) {
   expect(data.cache.previews.size).to.equal(2)
   expect(data.cache.captions.size).to.equal(3)
   expect(data.cache.torrents.size).to.equal(4)
+  expect(data.cache.storyboards.size).to.equal(5)
 
   expect(data.signup.enabled).to.be.false
   expect(data.signup.limit).to.equal(5)
@@ -190,7 +192,7 @@ function checkUpdatedConfig (data: CustomConfig) {
   expect(data.transcoding.resolutions['2160p']).to.be.false
   expect(data.transcoding.alwaysTranscodeOriginalResolution).to.be.false
   expect(data.transcoding.hls.enabled).to.be.false
-  expect(data.transcoding.webtorrent.enabled).to.be.true
+  expect(data.transcoding.webVideos.enabled).to.be.true
 
   expect(data.live.enabled).to.be.true
   expect(data.live.allowReplay).to.be.true
@@ -290,6 +292,9 @@ const newCustomConfig: CustomConfig = {
     },
     torrents: {
       size: 4
+    },
+    storyboards: {
+      size: 5
     }
   },
   signup: {
@@ -339,7 +344,7 @@ const newCustomConfig: CustomConfig = {
       '2160p': false
     },
     alwaysTranscodeOriginalResolution: false,
-    webtorrent: {
+    webVideos: {
       enabled: true
     },
     hls: {
diff --git a/server/tests/api/server/follows.ts b/server/tests/api/server/follows.ts
index 2a5fff82b..e3e4605ee 100644
--- a/server/tests/api/server/follows.ts
+++ b/server/tests/api/server/follows.ts
@@ -6,611 +6,636 @@ import { Video, VideoPrivacy } from '@shared/models'
 import { cleanupTests, createMultipleServers, PeerTubeServer, setAccessTokensToServers, waitJobs } from '@shared/server-commands'
 
 describe('Test follows', function () {
-  let servers: PeerTubeServer[] = []
 
-  before(async function () {
-    this.timeout(120000)
+  describe('Complex follow', function () {
+    let servers: PeerTubeServer[] = []
 
-    servers = await createMultipleServers(3)
+    before(async function () {
+      this.timeout(120000)
 
-    // Get the access tokens
-    await setAccessTokensToServers(servers)
-  })
+      servers = await createMultipleServers(3)
 
-  describe('Data propagation after follow', function () {
+      // Get the access tokens
+      await setAccessTokensToServers(servers)
+    })
 
-    it('Should not have followers/followings', async function () {
-      for (const server of servers) {
-        const bodies = await Promise.all([
-          server.follows.getFollowers({ start: 0, count: 5, sort: 'createdAt' }),
-          server.follows.getFollowings({ start: 0, count: 5, sort: 'createdAt' })
-        ])
+    describe('Data propagation after follow', function () {
 
-        for (const body of bodies) {
-          expect(body.total).to.equal(0)
+      it('Should not have followers/followings', async function () {
+        for (const server of servers) {
+          const bodies = await Promise.all([
+            server.follows.getFollowers({ start: 0, count: 5, sort: 'createdAt' }),
+            server.follows.getFollowings({ start: 0, count: 5, sort: 'createdAt' })
+          ])
 
-          const follows = body.data
-          expect(follows).to.be.an('array')
-          expect(follows).to.have.lengthOf(0)
+          for (const body of bodies) {
+            expect(body.total).to.equal(0)
+
+            const follows = body.data
+            expect(follows).to.be.an('array')
+            expect(follows).to.have.lengthOf(0)
+          }
         }
-      }
-    })
+      })
+
+      it('Should have server 1 following root account of server 2 and server 3', async function () {
+        this.timeout(30000)
 
-    it('Should have server 1 following root account of server 2 and server 3', async function () {
-      this.timeout(30000)
+        await servers[0].follows.follow({
+          hosts: [ servers[2].url ],
+          handles: [ 'root@' + servers[1].host ]
+        })
 
-      await servers[0].follows.follow({
-        hosts: [ servers[2].url ],
-        handles: [ 'root@' + servers[1].host ]
+        await waitJobs(servers)
       })
 
-      await waitJobs(servers)
-    })
+      it('Should have 2 followings on server 1', async function () {
+        const body = await servers[0].follows.getFollowings({ start: 0, count: 1, sort: 'createdAt' })
+        expect(body.total).to.equal(2)
 
-    it('Should have 2 followings on server 1', async function () {
-      const body = await servers[0].follows.getFollowings({ start: 0, count: 1, sort: 'createdAt' })
-      expect(body.total).to.equal(2)
+        let follows = body.data
+        expect(follows).to.be.an('array')
+        expect(follows).to.have.lengthOf(1)
 
-      let follows = body.data
-      expect(follows).to.be.an('array')
-      expect(follows).to.have.lengthOf(1)
+        const body2 = await servers[0].follows.getFollowings({ start: 1, count: 1, sort: 'createdAt' })
+        follows = follows.concat(body2.data)
 
-      const body2 = await servers[0].follows.getFollowings({ start: 1, count: 1, sort: 'createdAt' })
-      follows = follows.concat(body2.data)
+        const server2Follow = follows.find(f => f.following.host === servers[1].host)
+        const server3Follow = follows.find(f => f.following.host === servers[2].host)
 
-      const server2Follow = follows.find(f => f.following.host === servers[1].host)
-      const server3Follow = follows.find(f => f.following.host === servers[2].host)
+        expect(server2Follow).to.not.be.undefined
+        expect(server2Follow.following.name).to.equal('root')
+        expect(server2Follow.state).to.equal('accepted')
 
-      expect(server2Follow).to.not.be.undefined
-      expect(server2Follow.following.name).to.equal('root')
-      expect(server2Follow.state).to.equal('accepted')
+        expect(server3Follow).to.not.be.undefined
+        expect(server3Follow.following.name).to.equal('peertube')
+        expect(server3Follow.state).to.equal('accepted')
+      })
 
-      expect(server3Follow).to.not.be.undefined
-      expect(server3Follow.following.name).to.equal('peertube')
-      expect(server3Follow.state).to.equal('accepted')
-    })
+      it('Should have 0 followings on server 2 and 3', async function () {
+        for (const server of [ servers[1], servers[2] ]) {
+          const body = await server.follows.getFollowings({ start: 0, count: 5, sort: 'createdAt' })
+          expect(body.total).to.equal(0)
 
-    it('Should have 0 followings on server 2 and 3', async function () {
-      for (const server of [ servers[1], servers[2] ]) {
-        const body = await server.follows.getFollowings({ start: 0, count: 5, sort: 'createdAt' })
-        expect(body.total).to.equal(0)
+          const follows = body.data
+          expect(follows).to.be.an('array')
+          expect(follows).to.have.lengthOf(0)
+        }
+      })
+
+      it('Should have 1 followers on server 3', async function () {
+        const body = await servers[2].follows.getFollowers({ start: 0, count: 1, sort: 'createdAt' })
+        expect(body.total).to.equal(1)
 
         const follows = body.data
         expect(follows).to.be.an('array')
-        expect(follows).to.have.lengthOf(0)
-      }
-    })
+        expect(follows).to.have.lengthOf(1)
+        expect(follows[0].follower.host).to.equal(servers[0].host)
+      })
 
-    it('Should have 1 followers on server 3', async function () {
-      const body = await servers[2].follows.getFollowers({ start: 0, count: 1, sort: 'createdAt' })
-      expect(body.total).to.equal(1)
+      it('Should have 0 followers on server 1 and 2', async function () {
+        for (const server of [ servers[0], servers[1] ]) {
+          const body = await server.follows.getFollowers({ start: 0, count: 5, sort: 'createdAt' })
+          expect(body.total).to.equal(0)
 
-      const follows = body.data
-      expect(follows).to.be.an('array')
-      expect(follows).to.have.lengthOf(1)
-      expect(follows[0].follower.host).to.equal(servers[0].host)
-    })
+          const follows = body.data
+          expect(follows).to.be.an('array')
+          expect(follows).to.have.lengthOf(0)
+        }
+      })
 
-    it('Should have 0 followers on server 1 and 2', async function () {
-      for (const server of [ servers[0], servers[1] ]) {
-        const body = await server.follows.getFollowers({ start: 0, count: 5, sort: 'createdAt' })
-        expect(body.total).to.equal(0)
+      it('Should search/filter followings on server 1', async function () {
+        const sort = 'createdAt'
+        const start = 0
+        const count = 1
 
-        const follows = body.data
-        expect(follows).to.be.an('array')
-        expect(follows).to.have.lengthOf(0)
-      }
-    })
+        {
+          const search = ':' + servers[1].port
 
-    it('Should search/filter followings on server 1', async function () {
-      const sort = 'createdAt'
-      const start = 0
-      const count = 1
+          {
+            const body = await servers[0].follows.getFollowings({ start, count, sort, search })
+            expect(body.total).to.equal(1)
 
-      {
-        const search = ':' + servers[1].port
+            const follows = body.data
+            expect(follows).to.have.lengthOf(1)
+            expect(follows[0].following.host).to.equal(servers[1].host)
+          }
 
-        {
-          const body = await servers[0].follows.getFollowings({ start, count, sort, search })
-          expect(body.total).to.equal(1)
+          {
+            const body = await servers[0].follows.getFollowings({ start, count, sort, search, state: 'accepted' })
+            expect(body.total).to.equal(1)
+            expect(body.data).to.have.lengthOf(1)
+          }
 
-          const follows = body.data
-          expect(follows).to.have.lengthOf(1)
-          expect(follows[0].following.host).to.equal(servers[1].host)
-        }
+          {
+            const body = await servers[0].follows.getFollowings({ start, count, sort, search, state: 'accepted', actorType: 'Person' })
+            expect(body.total).to.equal(1)
+            expect(body.data).to.have.lengthOf(1)
+          }
 
-        {
-          const body = await servers[0].follows.getFollowings({ start, count, sort, search, state: 'accepted' })
-          expect(body.total).to.equal(1)
-          expect(body.data).to.have.lengthOf(1)
+          {
+            const body = await servers[0].follows.getFollowings({
+              start,
+              count,
+              sort,
+              search,
+              state: 'accepted',
+              actorType: 'Application'
+            })
+            expect(body.total).to.equal(0)
+            expect(body.data).to.have.lengthOf(0)
+          }
+
+          {
+            const body = await servers[0].follows.getFollowings({ start, count, sort, search, state: 'pending' })
+            expect(body.total).to.equal(0)
+            expect(body.data).to.have.lengthOf(0)
+          }
         }
 
         {
-          const body = await servers[0].follows.getFollowings({ start, count, sort, search, state: 'accepted', actorType: 'Person' })
+          const body = await servers[0].follows.getFollowings({ start, count, sort, search: 'root' })
           expect(body.total).to.equal(1)
           expect(body.data).to.have.lengthOf(1)
         }
 
         {
-          const body = await servers[0].follows.getFollowings({
-            start,
-            count,
-            sort,
-            search,
-            state: 'accepted',
-            actorType: 'Application'
-          })
+          const body = await servers[0].follows.getFollowings({ start, count, sort, search: 'bla' })
           expect(body.total).to.equal(0)
-          expect(body.data).to.have.lengthOf(0)
-        }
 
-        {
-          const body = await servers[0].follows.getFollowings({ start, count, sort, search, state: 'pending' })
-          expect(body.total).to.equal(0)
           expect(body.data).to.have.lengthOf(0)
         }
-      }
+      })
 
-      {
-        const body = await servers[0].follows.getFollowings({ start, count, sort, search: 'root' })
-        expect(body.total).to.equal(1)
-        expect(body.data).to.have.lengthOf(1)
-      }
+      it('Should search/filter followers on server 2', async function () {
+        const start = 0
+        const count = 5
+        const sort = 'createdAt'
 
-      {
-        const body = await servers[0].follows.getFollowings({ start, count, sort, search: 'bla' })
-        expect(body.total).to.equal(0)
+        {
+          const search = servers[0].port + ''
 
-        expect(body.data).to.have.lengthOf(0)
-      }
-    })
+          {
+            const body = await servers[2].follows.getFollowers({ start, count, sort, search })
+            expect(body.total).to.equal(1)
 
-    it('Should search/filter followers on server 2', async function () {
-      const start = 0
-      const count = 5
-      const sort = 'createdAt'
+            const follows = body.data
+            expect(follows).to.have.lengthOf(1)
+            expect(follows[0].following.host).to.equal(servers[2].host)
+          }
 
-      {
-        const search = servers[0].port + ''
+          {
+            const body = await servers[2].follows.getFollowers({ start, count, sort, search, state: 'accepted' })
+            expect(body.total).to.equal(1)
+            expect(body.data).to.have.lengthOf(1)
+          }
 
-        {
-          const body = await servers[2].follows.getFollowers({ start, count, sort, search })
-          expect(body.total).to.equal(1)
+          {
+            const body = await servers[2].follows.getFollowers({ start, count, sort, search, state: 'accepted', actorType: 'Person' })
+            expect(body.total).to.equal(0)
+            expect(body.data).to.have.lengthOf(0)
+          }
 
-          const follows = body.data
-          expect(follows).to.have.lengthOf(1)
-          expect(follows[0].following.host).to.equal(servers[2].host)
-        }
+          {
+            const body = await servers[2].follows.getFollowers({
+              start,
+              count,
+              sort,
+              search,
+              state: 'accepted',
+              actorType: 'Application'
+            })
+            expect(body.total).to.equal(1)
+            expect(body.data).to.have.lengthOf(1)
+          }
 
-        {
-          const body = await servers[2].follows.getFollowers({ start, count, sort, search, state: 'accepted' })
-          expect(body.total).to.equal(1)
-          expect(body.data).to.have.lengthOf(1)
+          {
+            const body = await servers[2].follows.getFollowers({ start, count, sort, search, state: 'pending' })
+            expect(body.total).to.equal(0)
+            expect(body.data).to.have.lengthOf(0)
+          }
         }
 
         {
-          const body = await servers[2].follows.getFollowers({ start, count, sort, search, state: 'accepted', actorType: 'Person' })
+          const body = await servers[2].follows.getFollowers({ start, count, sort, search: 'bla' })
           expect(body.total).to.equal(0)
-          expect(body.data).to.have.lengthOf(0)
-        }
 
-        {
-          const body = await servers[2].follows.getFollowers({
-            start,
-            count,
-            sort,
-            search,
-            state: 'accepted',
-            actorType: 'Application'
-          })
-          expect(body.total).to.equal(1)
-          expect(body.data).to.have.lengthOf(1)
+          const follows = body.data
+          expect(follows).to.have.lengthOf(0)
         }
+      })
 
-        {
-          const body = await servers[2].follows.getFollowers({ start, count, sort, search, state: 'pending' })
-          expect(body.total).to.equal(0)
-          expect(body.data).to.have.lengthOf(0)
-        }
-      }
+      it('Should have the correct follows counts', async function () {
+        await expectAccountFollows({ server: servers[0], handle: 'peertube@' + servers[0].host, followers: 0, following: 2 })
+        await expectAccountFollows({ server: servers[0], handle: 'root@' + servers[1].host, followers: 1, following: 0 })
+        await expectAccountFollows({ server: servers[0], handle: 'peertube@' + servers[2].host, followers: 1, following: 0 })
+
+        // Server 2 and 3 does not know server 1 follow another server (there was not a refresh)
+        await expectAccountFollows({ server: servers[1], handle: 'peertube@' + servers[0].host, followers: 0, following: 1 })
+        await expectAccountFollows({ server: servers[1], handle: 'root@' + servers[1].host, followers: 1, following: 0 })
+        await expectAccountFollows({ server: servers[1], handle: 'peertube@' + servers[1].host, followers: 0, following: 0 })
+
+        await expectAccountFollows({ server: servers[2], handle: 'peertube@' + servers[0].host, followers: 0, following: 1 })
+        await expectAccountFollows({ server: servers[2], handle: 'peertube@' + servers[2].host, followers: 1, following: 0 })
+      })
+
+      it('Should unfollow server 3 on server 1', async function () {
+        this.timeout(15000)
+
+        await servers[0].follows.unfollow({ target: servers[2] })
 
-      {
-        const body = await servers[2].follows.getFollowers({ start, count, sort, search: 'bla' })
+        await waitJobs(servers)
+      })
+
+      it('Should not follow server 3 on server 1 anymore', async function () {
+        const body = await servers[0].follows.getFollowings({ start: 0, count: 2, sort: 'createdAt' })
+        expect(body.total).to.equal(1)
+
+        const follows = body.data
+        expect(follows).to.be.an('array')
+        expect(follows).to.have.lengthOf(1)
+
+        expect(follows[0].following.host).to.equal(servers[1].host)
+      })
+
+      it('Should not have server 1 as follower on server 3 anymore', async function () {
+        const body = await servers[2].follows.getFollowers({ start: 0, count: 1, sort: 'createdAt' })
         expect(body.total).to.equal(0)
 
         const follows = body.data
+        expect(follows).to.be.an('array')
         expect(follows).to.have.lengthOf(0)
-      }
-    })
+      })
 
-    it('Should have the correct follows counts', async function () {
-      await expectAccountFollows({ server: servers[0], handle: 'peertube@' + servers[0].host, followers: 0, following: 2 })
-      await expectAccountFollows({ server: servers[0], handle: 'root@' + servers[1].host, followers: 1, following: 0 })
-      await expectAccountFollows({ server: servers[0], handle: 'peertube@' + servers[2].host, followers: 1, following: 0 })
+      it('Should have the correct follows counts after the unfollow', async function () {
+        await expectAccountFollows({ server: servers[0], handle: 'peertube@' + servers[0].host, followers: 0, following: 1 })
+        await expectAccountFollows({ server: servers[0], handle: 'root@' + servers[1].host, followers: 1, following: 0 })
+        await expectAccountFollows({ server: servers[0], handle: 'peertube@' + servers[2].host, followers: 0, following: 0 })
 
-      // Server 2 and 3 does not know server 1 follow another server (there was not a refresh)
-      await expectAccountFollows({ server: servers[1], handle: 'peertube@' + servers[0].host, followers: 0, following: 1 })
-      await expectAccountFollows({ server: servers[1], handle: 'root@' + servers[1].host, followers: 1, following: 0 })
-      await expectAccountFollows({ server: servers[1], handle: 'peertube@' + servers[1].host, followers: 0, following: 0 })
+        await expectAccountFollows({ server: servers[1], handle: 'peertube@' + servers[0].host, followers: 0, following: 1 })
+        await expectAccountFollows({ server: servers[1], handle: 'root@' + servers[1].host, followers: 1, following: 0 })
+        await expectAccountFollows({ server: servers[1], handle: 'peertube@' + servers[1].host, followers: 0, following: 0 })
 
-      await expectAccountFollows({ server: servers[2], handle: 'peertube@' + servers[0].host, followers: 0, following: 1 })
-      await expectAccountFollows({ server: servers[2], handle: 'peertube@' + servers[2].host, followers: 1, following: 0 })
-    })
+        await expectAccountFollows({ server: servers[2], handle: 'peertube@' + servers[0].host, followers: 0, following: 0 })
+        await expectAccountFollows({ server: servers[2], handle: 'peertube@' + servers[2].host, followers: 0, following: 0 })
+      })
 
-    it('Should unfollow server 3 on server 1', async function () {
-      this.timeout(15000)
+      it('Should upload a video on server 2 and 3 and propagate only the video of server 2', async function () {
+        this.timeout(160000)
 
-      await servers[0].follows.unfollow({ target: servers[2] })
+        await servers[1].videos.upload({ attributes: { name: 'server2' } })
+        await servers[2].videos.upload({ attributes: { name: 'server3' } })
 
-      await waitJobs(servers)
-    })
+        await waitJobs(servers)
 
-    it('Should not follow server 3 on server 1 anymore', async function () {
-      const body = await servers[0].follows.getFollowings({ start: 0, count: 2, sort: 'createdAt' })
-      expect(body.total).to.equal(1)
+        {
+          const { total, data } = await servers[0].videos.list()
+          expect(total).to.equal(1)
+          expect(data[0].name).to.equal('server2')
+        }
 
-      const follows = body.data
-      expect(follows).to.be.an('array')
-      expect(follows).to.have.lengthOf(1)
+        {
+          const { total, data } = await servers[1].videos.list()
+          expect(total).to.equal(1)
+          expect(data[0].name).to.equal('server2')
+        }
 
-      expect(follows[0].following.host).to.equal(servers[1].host)
-    })
+        {
+          const { total, data } = await servers[2].videos.list()
+          expect(total).to.equal(1)
+          expect(data[0].name).to.equal('server3')
+        }
+      })
 
-    it('Should not have server 1 as follower on server 3 anymore', async function () {
-      const body = await servers[2].follows.getFollowers({ start: 0, count: 1, sort: 'createdAt' })
-      expect(body.total).to.equal(0)
+      it('Should remove account follow', async function () {
+        this.timeout(15000)
 
-      const follows = body.data
-      expect(follows).to.be.an('array')
-      expect(follows).to.have.lengthOf(0)
-    })
+        await servers[0].follows.unfollow({ target: 'root@' + servers[1].host })
 
-    it('Should have the correct follows counts after the unfollow', async function () {
-      await expectAccountFollows({ server: servers[0], handle: 'peertube@' + servers[0].host, followers: 0, following: 1 })
-      await expectAccountFollows({ server: servers[0], handle: 'root@' + servers[1].host, followers: 1, following: 0 })
-      await expectAccountFollows({ server: servers[0], handle: 'peertube@' + servers[2].host, followers: 0, following: 0 })
+        await waitJobs(servers)
+      })
 
-      await expectAccountFollows({ server: servers[1], handle: 'peertube@' + servers[0].host, followers: 0, following: 1 })
-      await expectAccountFollows({ server: servers[1], handle: 'root@' + servers[1].host, followers: 1, following: 0 })
-      await expectAccountFollows({ server: servers[1], handle: 'peertube@' + servers[1].host, followers: 0, following: 0 })
+      it('Should have removed the account follow', async function () {
+        await expectAccountFollows({ server: servers[0], handle: 'root@' + servers[1].host, followers: 0, following: 0 })
+        await expectAccountFollows({ server: servers[1], handle: 'root@' + servers[1].host, followers: 0, following: 0 })
 
-      await expectAccountFollows({ server: servers[2], handle: 'peertube@' + servers[0].host, followers: 0, following: 0 })
-      await expectAccountFollows({ server: servers[2], handle: 'peertube@' + servers[2].host, followers: 0, following: 0 })
-    })
+        {
+          const { total, data } = await servers[0].follows.getFollowings()
+          expect(total).to.equal(0)
+          expect(data).to.have.lengthOf(0)
+        }
 
-    it('Should upload a video on server 2 and 3 and propagate only the video of server 2', async function () {
-      this.timeout(160000)
+        {
+          const { total, data } = await servers[0].videos.list()
+          expect(total).to.equal(0)
+          expect(data).to.have.lengthOf(0)
+        }
+      })
 
-      await servers[1].videos.upload({ attributes: { name: 'server2' } })
-      await servers[2].videos.upload({ attributes: { name: 'server3' } })
+      it('Should follow a channel', async function () {
+        this.timeout(15000)
 
-      await waitJobs(servers)
+        await servers[0].follows.follow({
+          handles: [ 'root_channel@' + servers[1].host ]
+        })
 
-      {
-        const { total, data } = await servers[0].videos.list()
-        expect(total).to.equal(1)
-        expect(data[0].name).to.equal('server2')
-      }
+        await waitJobs(servers)
 
-      {
-        const { total, data } = await servers[1].videos.list()
-        expect(total).to.equal(1)
-        expect(data[0].name).to.equal('server2')
-      }
+        await expectChannelsFollows({ server: servers[0], handle: 'root_channel@' + servers[1].host, followers: 1, following: 0 })
+        await expectChannelsFollows({ server: servers[1], handle: 'root_channel@' + servers[1].host, followers: 1, following: 0 })
 
-      {
-        const { total, data } = await servers[2].videos.list()
-        expect(total).to.equal(1)
-        expect(data[0].name).to.equal('server3')
-      }
+        {
+          const { total, data } = await servers[0].follows.getFollowings()
+          expect(total).to.equal(1)
+          expect(data).to.have.lengthOf(1)
+        }
+
+        {
+          const { total, data } = await servers[0].videos.list()
+          expect(total).to.equal(1)
+          expect(data).to.have.lengthOf(1)
+        }
+      })
     })
 
-    it('Should remove account follow', async function () {
-      this.timeout(15000)
+    describe('Should propagate data on a new server follow', function () {
+      let video4: Video
 
-      await servers[0].follows.unfollow({ target: 'root@' + servers[1].host })
+      before(async function () {
+        this.timeout(240000)
 
-      await waitJobs(servers)
-    })
+        const video4Attributes = {
+          name: 'server3-4',
+          category: 2,
+          nsfw: true,
+          licence: 6,
+          tags: [ 'tag1', 'tag2', 'tag3' ]
+        }
 
-    it('Should have removed the account follow', async function () {
-      await expectAccountFollows({ server: servers[0], handle: 'root@' + servers[1].host, followers: 0, following: 0 })
-      await expectAccountFollows({ server: servers[1], handle: 'root@' + servers[1].host, followers: 0, following: 0 })
+        await servers[2].videos.upload({ attributes: { name: 'server3-2' } })
+        await servers[2].videos.upload({ attributes: { name: 'server3-3' } })
 
-      {
-        const { total, data } = await servers[0].follows.getFollowings()
-        expect(total).to.equal(0)
-        expect(data).to.have.lengthOf(0)
-      }
+        const video4CreateResult = await servers[2].videos.upload({ attributes: video4Attributes })
 
-      {
-        const { total, data } = await servers[0].videos.list()
-        expect(total).to.equal(0)
-        expect(data).to.have.lengthOf(0)
-      }
-    })
+        await servers[2].videos.upload({ attributes: { name: 'server3-5' } })
+        await servers[2].videos.upload({ attributes: { name: 'server3-6' } })
 
-    it('Should follow a channel', async function () {
-      this.timeout(15000)
+        {
+          const userAccessToken = await servers[2].users.generateUserAndToken('captain')
 
-      await servers[0].follows.follow({
-        handles: [ 'root_channel@' + servers[1].host ]
-      })
+          await servers[2].videos.rate({ id: video4CreateResult.id, rating: 'like' })
+          await servers[2].videos.rate({ token: userAccessToken, id: video4CreateResult.id, rating: 'dislike' })
+        }
 
-      await waitJobs(servers)
+        {
+          await servers[2].comments.createThread({ videoId: video4CreateResult.id, text: 'my super first comment' })
 
-      await expectChannelsFollows({ server: servers[0], handle: 'root_channel@' + servers[1].host, followers: 1, following: 0 })
-      await expectChannelsFollows({ server: servers[1], handle: 'root_channel@' + servers[1].host, followers: 1, following: 0 })
+          await servers[2].comments.addReplyToLastThread({ text: 'my super answer to thread 1' })
+          await servers[2].comments.addReplyToLastReply({ text: 'my super answer to answer of thread 1' })
+          await servers[2].comments.addReplyToLastThread({ text: 'my second answer to thread 1' })
+        }
 
-      {
-        const { total, data } = await servers[0].follows.getFollowings()
-        expect(total).to.equal(1)
-        expect(data).to.have.lengthOf(1)
-      }
+        {
+          const { id: threadId } = await servers[2].comments.createThread({ videoId: video4CreateResult.id, text: 'will be deleted' })
+          await servers[2].comments.addReplyToLastThread({ text: 'answer to deleted' })
 
-      {
-        const { total, data } = await servers[0].videos.list()
-        expect(total).to.equal(1)
-        expect(data).to.have.lengthOf(1)
-      }
-    })
-  })
+          const { id: replyId } = await servers[2].comments.addReplyToLastThread({ text: 'will also be deleted' })
 
-  describe('Should propagate data on a new server follow', function () {
-    let video4: Video
+          await servers[2].comments.addReplyToLastReply({ text: 'my second answer to deleted' })
 
-    before(async function () {
-      this.timeout(120000)
+          await servers[2].comments.delete({ videoId: video4CreateResult.id, commentId: threadId })
+          await servers[2].comments.delete({ videoId: video4CreateResult.id, commentId: replyId })
+        }
 
-      const video4Attributes = {
-        name: 'server3-4',
-        category: 2,
-        nsfw: true,
-        licence: 6,
-        tags: [ 'tag1', 'tag2', 'tag3' ]
-      }
+        await servers[2].captions.add({
+          language: 'ar',
+          videoId: video4CreateResult.id,
+          fixture: 'subtitle-good2.vtt'
+        })
 
-      await servers[2].videos.upload({ attributes: { name: 'server3-2' } })
-      await servers[2].videos.upload({ attributes: { name: 'server3-3' } })
-      const video4CreateResult = await servers[2].videos.upload({ attributes: video4Attributes })
-      await servers[2].videos.upload({ attributes: { name: 'server3-5' } })
-      await servers[2].videos.upload({ attributes: { name: 'server3-6' } })
+        await waitJobs(servers)
 
-      {
-        const userAccessToken = await servers[2].users.generateUserAndToken('captain')
+        // Server 1 follows server 3
+        await servers[0].follows.follow({ hosts: [ servers[2].url ] })
 
-        await servers[2].videos.rate({ id: video4CreateResult.id, rating: 'like' })
-        await servers[2].videos.rate({ token: userAccessToken, id: video4CreateResult.id, rating: 'dislike' })
-      }
+        await waitJobs(servers)
+      })
 
-      {
-        await servers[2].comments.createThread({ videoId: video4CreateResult.id, text: 'my super first comment' })
+      it('Should have the correct follows counts', async function () {
+        await expectAccountFollows({ server: servers[0], handle: 'peertube@' + servers[0].host, followers: 0, following: 2 })
+        await expectAccountFollows({ server: servers[0], handle: 'root@' + servers[1].host, followers: 0, following: 0 })
+        await expectChannelsFollows({ server: servers[0], handle: 'root_channel@' + servers[1].host, followers: 1, following: 0 })
+        await expectAccountFollows({ server: servers[0], handle: 'peertube@' + servers[2].host, followers: 1, following: 0 })
 
-        await servers[2].comments.addReplyToLastThread({ text: 'my super answer to thread 1' })
-        await servers[2].comments.addReplyToLastReply({ text: 'my super answer to answer of thread 1' })
-        await servers[2].comments.addReplyToLastThread({ text: 'my second answer to thread 1' })
-      }
+        await expectAccountFollows({ server: servers[1], handle: 'peertube@' + servers[0].host, followers: 0, following: 1 })
+        await expectAccountFollows({ server: servers[1], handle: 'peertube@' + servers[1].host, followers: 0, following: 0 })
+        await expectAccountFollows({ server: servers[1], handle: 'root@' + servers[1].host, followers: 0, following: 0 })
+        await expectChannelsFollows({ server: servers[1], handle: 'root_channel@' + servers[1].host, followers: 1, following: 0 })
 
-      {
-        const { id: threadId } = await servers[2].comments.createThread({ videoId: video4CreateResult.id, text: 'will be deleted' })
-        await servers[2].comments.addReplyToLastThread({ text: 'answer to deleted' })
+        await expectAccountFollows({ server: servers[2], handle: 'peertube@' + servers[0].host, followers: 0, following: 1 })
+        await expectAccountFollows({ server: servers[2], handle: 'peertube@' + servers[2].host, followers: 1, following: 0 })
+      })
 
-        const { id: replyId } = await servers[2].comments.addReplyToLastThread({ text: 'will also be deleted' })
+      it('Should have propagated videos', async function () {
+        const { total, data } = await servers[0].videos.list()
+        expect(total).to.equal(7)
+
+        const video2 = data.find(v => v.name === 'server3-2')
+        video4 = data.find(v => v.name === 'server3-4')
+        const video6 = data.find(v => v.name === 'server3-6')
+
+        expect(video2).to.not.be.undefined
+        expect(video4).to.not.be.undefined
+        expect(video6).to.not.be.undefined
+
+        const isLocal = false
+        const checkAttributes = {
+          name: 'server3-4',
+          category: 2,
+          licence: 6,
+          language: 'zh',
+          nsfw: true,
+          description: 'my super description',
+          support: 'my super support text',
+          account: {
+            name: 'root',
+            host: servers[2].host
+          },
+          isLocal,
+          commentsEnabled: true,
+          downloadEnabled: true,
+          duration: 5,
+          tags: [ 'tag1', 'tag2', 'tag3' ],
+          privacy: VideoPrivacy.PUBLIC,
+          likes: 1,
+          dislikes: 1,
+          channel: {
+            displayName: 'Main root channel',
+            name: 'root_channel',
+            description: '',
+            isLocal
+          },
+          fixture: 'video_short.webm',
+          files: [
+            {
+              resolution: 720,
+              size: 218910
+            }
+          ]
+        }
+        await completeVideoCheck({
+          server: servers[0],
+          originServer: servers[2],
+          videoUUID: video4.uuid,
+          attributes: checkAttributes
+        })
+      })
 
-        await servers[2].comments.addReplyToLastReply({ text: 'my second answer to deleted' })
+      it('Should have propagated comments', async function () {
+        const { total, data } = await servers[0].comments.listThreads({ videoId: video4.id, sort: 'createdAt' })
 
-        await servers[2].comments.delete({ videoId: video4CreateResult.id, commentId: threadId })
-        await servers[2].comments.delete({ videoId: video4CreateResult.id, commentId: replyId })
-      }
+        expect(total).to.equal(2)
+        expect(data).to.be.an('array')
+        expect(data).to.have.lengthOf(2)
 
-      await servers[2].captions.add({
-        language: 'ar',
-        videoId: video4CreateResult.id,
-        fixture: 'subtitle-good2.vtt'
-      })
+        {
+          const comment = data[0]
+          expect(comment.inReplyToCommentId).to.be.null
+          expect(comment.text).equal('my super first comment')
+          expect(comment.videoId).to.equal(video4.id)
+          expect(comment.id).to.equal(comment.threadId)
+          expect(comment.account.name).to.equal('root')
+          expect(comment.account.host).to.equal(servers[2].host)
+          expect(comment.totalReplies).to.equal(3)
+          expect(dateIsValid(comment.createdAt as string)).to.be.true
+          expect(dateIsValid(comment.updatedAt as string)).to.be.true
+
+          const threadId = comment.threadId
+
+          const tree = await servers[0].comments.getThread({ videoId: video4.id, threadId })
+          expect(tree.comment.text).equal('my super first comment')
+          expect(tree.children).to.have.lengthOf(2)
+
+          const firstChild = tree.children[0]
+          expect(firstChild.comment.text).to.equal('my super answer to thread 1')
+          expect(firstChild.children).to.have.lengthOf(1)
+
+          const childOfFirstChild = firstChild.children[0]
+          expect(childOfFirstChild.comment.text).to.equal('my super answer to answer of thread 1')
+          expect(childOfFirstChild.children).to.have.lengthOf(0)
+
+          const secondChild = tree.children[1]
+          expect(secondChild.comment.text).to.equal('my second answer to thread 1')
+          expect(secondChild.children).to.have.lengthOf(0)
+        }
 
-      await waitJobs(servers)
+        {
+          const deletedComment = data[1]
+          expect(deletedComment).to.not.be.undefined
+          expect(deletedComment.isDeleted).to.be.true
+          expect(deletedComment.deletedAt).to.not.be.null
+          expect(deletedComment.text).to.equal('')
+          expect(deletedComment.inReplyToCommentId).to.be.null
+          expect(deletedComment.account).to.be.null
+          expect(deletedComment.totalReplies).to.equal(2)
+          expect(dateIsValid(deletedComment.deletedAt as string)).to.be.true
+
+          const tree = await servers[0].comments.getThread({ videoId: video4.id, threadId: deletedComment.threadId })
+          const [ commentRoot, deletedChildRoot ] = tree.children
+
+          expect(deletedChildRoot).to.not.be.undefined
+          expect(deletedChildRoot.comment.isDeleted).to.be.true
+          expect(deletedChildRoot.comment.deletedAt).to.not.be.null
+          expect(deletedChildRoot.comment.text).to.equal('')
+          expect(deletedChildRoot.comment.inReplyToCommentId).to.equal(deletedComment.id)
+          expect(deletedChildRoot.comment.account).to.be.null
+          expect(deletedChildRoot.children).to.have.lengthOf(1)
+
+          const answerToDeletedChild = deletedChildRoot.children[0]
+          expect(answerToDeletedChild.comment).to.not.be.undefined
+          expect(answerToDeletedChild.comment.inReplyToCommentId).to.equal(deletedChildRoot.comment.id)
+          expect(answerToDeletedChild.comment.text).to.equal('my second answer to deleted')
+          expect(answerToDeletedChild.comment.account.name).to.equal('root')
+
+          expect(commentRoot.comment).to.not.be.undefined
+          expect(commentRoot.comment.inReplyToCommentId).to.equal(deletedComment.id)
+          expect(commentRoot.comment.text).to.equal('answer to deleted')
+          expect(commentRoot.comment.account.name).to.equal('root')
+        }
+      })
 
-      // Server 1 follows server 3
-      await servers[0].follows.follow({ hosts: [ servers[2].url ] })
+      it('Should have propagated captions', async function () {
+        const body = await servers[0].captions.list({ videoId: video4.id })
+        expect(body.total).to.equal(1)
+        expect(body.data).to.have.lengthOf(1)
 
-      await waitJobs(servers)
-    })
+        const caption1 = body.data[0]
+        expect(caption1.language.id).to.equal('ar')
+        expect(caption1.language.label).to.equal('Arabic')
+        expect(caption1.captionPath).to.match(new RegExp('^/lazy-static/video-captions/.+-ar.vtt$'))
+        await testCaptionFile(servers[0].url, caption1.captionPath, 'Subtitle good 2.')
+      })
 
-    it('Should have the correct follows counts', async function () {
-      await expectAccountFollows({ server: servers[0], handle: 'peertube@' + servers[0].host, followers: 0, following: 2 })
-      await expectAccountFollows({ server: servers[0], handle: 'root@' + servers[1].host, followers: 0, following: 0 })
-      await expectChannelsFollows({ server: servers[0], handle: 'root_channel@' + servers[1].host, followers: 1, following: 0 })
-      await expectAccountFollows({ server: servers[0], handle: 'peertube@' + servers[2].host, followers: 1, following: 0 })
+      it('Should unfollow server 3 on server 1 and does not list server 3 videos', async function () {
+        this.timeout(5000)
 
-      await expectAccountFollows({ server: servers[1], handle: 'peertube@' + servers[0].host, followers: 0, following: 1 })
-      await expectAccountFollows({ server: servers[1], handle: 'peertube@' + servers[1].host, followers: 0, following: 0 })
-      await expectAccountFollows({ server: servers[1], handle: 'root@' + servers[1].host, followers: 0, following: 0 })
-      await expectChannelsFollows({ server: servers[1], handle: 'root_channel@' + servers[1].host, followers: 1, following: 0 })
+        await servers[0].follows.unfollow({ target: servers[2] })
 
-      await expectAccountFollows({ server: servers[2], handle: 'peertube@' + servers[0].host, followers: 0, following: 1 })
-      await expectAccountFollows({ server: servers[2], handle: 'peertube@' + servers[2].host, followers: 1, following: 0 })
-    })
+        await waitJobs(servers)
 
-    it('Should have propagated videos', async function () {
-      const { total, data } = await servers[0].videos.list()
-      expect(total).to.equal(7)
-
-      const video2 = data.find(v => v.name === 'server3-2')
-      video4 = data.find(v => v.name === 'server3-4')
-      const video6 = data.find(v => v.name === 'server3-6')
-
-      expect(video2).to.not.be.undefined
-      expect(video4).to.not.be.undefined
-      expect(video6).to.not.be.undefined
-
-      const isLocal = false
-      const checkAttributes = {
-        name: 'server3-4',
-        category: 2,
-        licence: 6,
-        language: 'zh',
-        nsfw: true,
-        description: 'my super description',
-        support: 'my super support text',
-        account: {
-          name: 'root',
-          host: servers[2].host
-        },
-        isLocal,
-        commentsEnabled: true,
-        downloadEnabled: true,
-        duration: 5,
-        tags: [ 'tag1', 'tag2', 'tag3' ],
-        privacy: VideoPrivacy.PUBLIC,
-        likes: 1,
-        dislikes: 1,
-        channel: {
-          displayName: 'Main root channel',
-          name: 'root_channel',
-          description: '',
-          isLocal
-        },
-        fixture: 'video_short.webm',
-        files: [
-          {
-            resolution: 720,
-            size: 218910
-          }
-        ]
-      }
-      await completeVideoCheck({
-        server: servers[0],
-        originServer: servers[2],
-        videoUUID: video4.uuid,
-        attributes: checkAttributes
+        const { total } = await servers[0].videos.list()
+        expect(total).to.equal(1)
       })
     })
 
-    it('Should have propagated comments', async function () {
-      const { total, data } = await servers[0].comments.listThreads({ videoId: video4.id, sort: 'createdAt' })
-
-      expect(total).to.equal(2)
-      expect(data).to.be.an('array')
-      expect(data).to.have.lengthOf(2)
-
-      {
-        const comment = data[0]
-        expect(comment.inReplyToCommentId).to.be.null
-        expect(comment.text).equal('my super first comment')
-        expect(comment.videoId).to.equal(video4.id)
-        expect(comment.id).to.equal(comment.threadId)
-        expect(comment.account.name).to.equal('root')
-        expect(comment.account.host).to.equal(servers[2].host)
-        expect(comment.totalReplies).to.equal(3)
-        expect(dateIsValid(comment.createdAt as string)).to.be.true
-        expect(dateIsValid(comment.updatedAt as string)).to.be.true
-
-        const threadId = comment.threadId
-
-        const tree = await servers[0].comments.getThread({ videoId: video4.id, threadId })
-        expect(tree.comment.text).equal('my super first comment')
-        expect(tree.children).to.have.lengthOf(2)
-
-        const firstChild = tree.children[0]
-        expect(firstChild.comment.text).to.equal('my super answer to thread 1')
-        expect(firstChild.children).to.have.lengthOf(1)
-
-        const childOfFirstChild = firstChild.children[0]
-        expect(childOfFirstChild.comment.text).to.equal('my super answer to answer of thread 1')
-        expect(childOfFirstChild.children).to.have.lengthOf(0)
-
-        const secondChild = tree.children[1]
-        expect(secondChild.comment.text).to.equal('my second answer to thread 1')
-        expect(secondChild.children).to.have.lengthOf(0)
-      }
-
-      {
-        const deletedComment = data[1]
-        expect(deletedComment).to.not.be.undefined
-        expect(deletedComment.isDeleted).to.be.true
-        expect(deletedComment.deletedAt).to.not.be.null
-        expect(deletedComment.text).to.equal('')
-        expect(deletedComment.inReplyToCommentId).to.be.null
-        expect(deletedComment.account).to.be.null
-        expect(deletedComment.totalReplies).to.equal(2)
-        expect(dateIsValid(deletedComment.deletedAt as string)).to.be.true
-
-        const tree = await servers[0].comments.getThread({ videoId: video4.id, threadId: deletedComment.threadId })
-        const [ commentRoot, deletedChildRoot ] = tree.children
-
-        expect(deletedChildRoot).to.not.be.undefined
-        expect(deletedChildRoot.comment.isDeleted).to.be.true
-        expect(deletedChildRoot.comment.deletedAt).to.not.be.null
-        expect(deletedChildRoot.comment.text).to.equal('')
-        expect(deletedChildRoot.comment.inReplyToCommentId).to.equal(deletedComment.id)
-        expect(deletedChildRoot.comment.account).to.be.null
-        expect(deletedChildRoot.children).to.have.lengthOf(1)
-
-        const answerToDeletedChild = deletedChildRoot.children[0]
-        expect(answerToDeletedChild.comment).to.not.be.undefined
-        expect(answerToDeletedChild.comment.inReplyToCommentId).to.equal(deletedChildRoot.comment.id)
-        expect(answerToDeletedChild.comment.text).to.equal('my second answer to deleted')
-        expect(answerToDeletedChild.comment.account.name).to.equal('root')
-
-        expect(commentRoot.comment).to.not.be.undefined
-        expect(commentRoot.comment.inReplyToCommentId).to.equal(deletedComment.id)
-        expect(commentRoot.comment.text).to.equal('answer to deleted')
-        expect(commentRoot.comment.account.name).to.equal('root')
-      }
+    after(async function () {
+      await cleanupTests(servers)
     })
+  })
 
-    it('Should have propagated captions', async function () {
-      const body = await servers[0].captions.list({ videoId: video4.id })
-      expect(body.total).to.equal(1)
-      expect(body.data).to.have.lengthOf(1)
+  describe('Simple data propagation propagate data on a new channel follow', function () {
+    let servers: PeerTubeServer[] = []
 
-      const caption1 = body.data[0]
-      expect(caption1.language.id).to.equal('ar')
-      expect(caption1.language.label).to.equal('Arabic')
-      expect(caption1.captionPath).to.match(new RegExp('^/lazy-static/video-captions/.+-ar.vtt$'))
-      await testCaptionFile(servers[0].url, caption1.captionPath, 'Subtitle good 2.')
-    })
+    before(async function () {
+      this.timeout(120000)
 
-    it('Should unfollow server 3 on server 1 and does not list server 3 videos', async function () {
-      this.timeout(5000)
+      servers = await createMultipleServers(3)
+      await setAccessTokensToServers(servers)
 
-      await servers[0].follows.unfollow({ target: servers[2] })
+      await servers[0].videos.upload({ attributes: { name: 'video to add' } })
 
       await waitJobs(servers)
 
-      const { total } = await servers[0].videos.list()
-      expect(total).to.equal(1)
+      for (const server of [ servers[1], servers[2] ]) {
+        const video = await server.videos.find({ name: 'video to add' })
+        expect(video).to.not.exist
+      }
     })
-  })
-
-  describe('Should propagate data on a new channel follow', function () {
 
-    before(async function () {
+    it('Should have propagated video after new channel follow', async function () {
       this.timeout(60000)
 
-      await servers[2].videos.upload({ attributes: { name: 'server3-7' } })
+      await servers[1].follows.follow({ handles: [ 'root_channel@' + servers[0].host ] })
 
       await waitJobs(servers)
 
-      const video = await servers[0].videos.find({ name: 'server3-7' })
-      expect(video).to.not.exist
+      const video = await servers[1].videos.find({ name: 'video to add' })
+      expect(video).to.exist
     })
 
-    it('Should have propagated channel video', async function () {
+    it('Should have propagated video after new account follow', async function () {
       this.timeout(60000)
 
-      await servers[0].follows.follow({ handles: [ 'root_channel@' + servers[2].host ] })
+      await servers[2].follows.follow({ handles: [ 'root@' + servers[0].host ] })
 
       await waitJobs(servers)
 
-      const video = await servers[0].videos.find({ name: 'server3-7' })
-
+      const video = await servers[2].videos.find({ name: 'video to add' })
       expect(video).to.exist
     })
-  })
 
-  after(async function () {
-    await cleanupTests(servers)
+    after(async function () {
+      await cleanupTests(servers)
+    })
   })
 })
diff --git a/server/tests/api/server/stats.ts b/server/tests/api/server/stats.ts
index aad0d231a..a1bf189fa 100644
--- a/server/tests/api/server/stats.ts
+++ b/server/tests/api/server/stats.ts
@@ -194,7 +194,7 @@ describe('Test stats (excluding redundancy)', function () {
       newConfig: {
         transcoding: {
           enabled: true,
-          webtorrent: {
+          webVideos: {
             enabled: true
           },
           hls: {
diff --git a/server/tests/api/transcoding/audio-only.ts b/server/tests/api/transcoding/audio-only.ts
index 1e31418e7..f4cc012ef 100644
--- a/server/tests/api/transcoding/audio-only.ts
+++ b/server/tests/api/transcoding/audio-only.ts
@@ -14,7 +14,7 @@ import {
 describe('Test audio only video transcoding', function () {
   let servers: PeerTubeServer[] = []
   let videoUUID: string
-  let webtorrentAudioFileUrl: string
+  let webVideoAudioFileUrl: string
   let fragmentedAudioFileUrl: string
 
   before(async function () {
@@ -37,7 +37,7 @@ describe('Test audio only video transcoding', function () {
         hls: {
           enabled: true
         },
-        webtorrent: {
+        web_videos: {
           enabled: true
         }
       }
@@ -71,7 +71,7 @@ describe('Test audio only video transcoding', function () {
       }
 
       if (server.serverNumber === 1) {
-        webtorrentAudioFileUrl = video.files[2].fileUrl
+        webVideoAudioFileUrl = video.files[2].fileUrl
         fragmentedAudioFileUrl = video.streamingPlaylists[0].files[2].fileUrl
       }
     }
@@ -79,7 +79,7 @@ describe('Test audio only video transcoding', function () {
 
   it('0p transcoded video should not have video', async function () {
     const paths = [
-      servers[0].servers.buildWebTorrentFilePath(webtorrentAudioFileUrl),
+      servers[0].servers.buildWebVideoFilePath(webVideoAudioFileUrl),
       servers[0].servers.buildFragmentedFilePath(videoUUID, fragmentedAudioFileUrl)
     ]
 
diff --git a/server/tests/api/transcoding/create-transcoding.ts b/server/tests/api/transcoding/create-transcoding.ts
index d6f5b01dc..9a891043c 100644
--- a/server/tests/api/transcoding/create-transcoding.ts
+++ b/server/tests/api/transcoding/create-transcoding.ts
@@ -96,12 +96,12 @@ function runTests (enableObjectStorage: boolean) {
     }
   })
 
-  it('Should generate WebTorrent', async function () {
+  it('Should generate Web Video', async function () {
     this.timeout(60000)
 
     await servers[0].videos.runTranscoding({
       videoId: videoUUID,
-      transcodingType: 'webtorrent'
+      transcodingType: 'web-video'
     })
 
     await waitJobs(servers)
@@ -117,13 +117,13 @@ function runTests (enableObjectStorage: boolean) {
     }
   })
 
-  it('Should generate WebTorrent from HLS only video', async function () {
+  it('Should generate Web Video from HLS only video', async function () {
     this.timeout(60000)
 
-    await servers[0].videos.removeAllWebTorrentFiles({ videoId: videoUUID })
+    await servers[0].videos.removeAllWebVideoFiles({ videoId: videoUUID })
     await waitJobs(servers)
 
-    await servers[0].videos.runTranscoding({ videoId: videoUUID, transcodingType: 'webtorrent' })
+    await servers[0].videos.runTranscoding({ videoId: videoUUID, transcodingType: 'web-video' })
     await waitJobs(servers)
 
     for (const server of servers) {
@@ -137,13 +137,13 @@ function runTests (enableObjectStorage: boolean) {
     }
   })
 
-  it('Should only generate WebTorrent', async function () {
+  it('Should only generate Web Video', async function () {
     this.timeout(60000)
 
     await servers[0].videos.removeHLSPlaylist({ videoId: videoUUID })
     await waitJobs(servers)
 
-    await servers[0].videos.runTranscoding({ videoId: videoUUID, transcodingType: 'webtorrent' })
+    await servers[0].videos.runTranscoding({ videoId: videoUUID, transcodingType: 'web-video' })
     await waitJobs(servers)
 
     for (const server of servers) {
@@ -165,7 +165,7 @@ function runTests (enableObjectStorage: boolean) {
           enabled: true,
           resolutions: ConfigCommand.getCustomConfigResolutions(false),
 
-          webtorrent: {
+          webVideos: {
             enabled: true
           },
           hls: {
@@ -201,7 +201,7 @@ function runTests (enableObjectStorage: boolean) {
           enabled: true,
           resolutions: ConfigCommand.getCustomConfigResolutions(true),
 
-          webtorrent: {
+          webVideos: {
             enabled: true
           },
           hls: {
diff --git a/server/tests/api/transcoding/hls.ts b/server/tests/api/transcoding/hls.ts
index c668d7e0b..d67043c2a 100644
--- a/server/tests/api/transcoding/hls.ts
+++ b/server/tests/api/transcoding/hls.ts
@@ -75,8 +75,8 @@ describe('Test HLS videos', function () {
 
     it('Should have the playlists/segment deleted from the disk', async function () {
       for (const server of servers) {
-        await checkDirectoryIsEmpty(server, 'videos', [ 'private' ])
-        await checkDirectoryIsEmpty(server, join('videos', 'private'))
+        await checkDirectoryIsEmpty(server, 'web-videos', [ 'private' ])
+        await checkDirectoryIsEmpty(server, join('web-videos', 'private'))
 
         await checkDirectoryIsEmpty(server, join('streaming-playlists', 'hls'), [ 'private' ])
         await checkDirectoryIsEmpty(server, join('streaming-playlists', 'hls', 'private'))
@@ -111,7 +111,7 @@ describe('Test HLS videos', function () {
     await doubleFollow(servers[0], servers[1])
   })
 
-  describe('With WebTorrent & HLS enabled', function () {
+  describe('With Web Video & HLS enabled', function () {
     runTestSuite(false)
   })
 
@@ -136,7 +136,7 @@ describe('Test HLS videos', function () {
             hls: {
               enabled: true
             },
-            webtorrent: {
+            webVideos: {
               enabled: false
             }
           }
diff --git a/server/tests/api/transcoding/transcoder.ts b/server/tests/api/transcoding/transcoder.ts
index 8a0a7f6d2..5386d236f 100644
--- a/server/tests/api/transcoding/transcoder.ts
+++ b/server/tests/api/transcoding/transcoder.ts
@@ -31,7 +31,7 @@ function updateConfigForTranscoding (server: PeerTubeServer) {
         allowAdditionalExtensions: true,
         allowAudioFiles: true,
         hls: { enabled: true },
-        webtorrent: { enabled: true },
+        webVideos: { enabled: true },
         resolutions: {
           '0p': false,
           '144p': true,
@@ -251,7 +251,7 @@ describe('Test video transcoding', function () {
         expect(videoDetails.files).to.have.lengthOf(5)
 
         const file = videoDetails.files.find(f => f.resolution.id === 240)
-        const path = servers[1].servers.buildWebTorrentFilePath(file.fileUrl)
+        const path = servers[1].servers.buildWebVideoFilePath(file.fileUrl)
         const probe = await getAudioStream(path)
 
         if (probe.audioStream) {
@@ -281,7 +281,7 @@ describe('Test video transcoding', function () {
         const videoDetails = await server.videos.get({ id: video.id })
 
         const file = videoDetails.files.find(f => f.resolution.id === 240)
-        const path = servers[1].servers.buildWebTorrentFilePath(file.fileUrl)
+        const path = servers[1].servers.buildWebVideoFilePath(file.fileUrl)
 
         expect(await hasAudioStream(path)).to.be.false
       }
@@ -310,7 +310,7 @@ describe('Test video transcoding', function () {
         const fixtureVideoProbe = await getAudioStream(fixturePath)
 
         const file = videoDetails.files.find(f => f.resolution.id === 240)
-        const path = servers[1].servers.buildWebTorrentFilePath(file.fileUrl)
+        const path = servers[1].servers.buildWebVideoFilePath(file.fileUrl)
 
         const videoProbe = await getAudioStream(path)
 
@@ -333,7 +333,7 @@ describe('Test video transcoding', function () {
           newConfig: {
             transcoding: {
               hls: { enabled: true },
-              webtorrent: { enabled: true },
+              webVideos: { enabled: true },
               resolutions: {
                 '0p': false,
                 '144p': false,
@@ -353,7 +353,7 @@ describe('Test video transcoding', function () {
       it('Should merge an audio file with the preview file', async function () {
         this.timeout(60_000)
 
-        const attributes = { name: 'audio_with_preview', previewfile: 'preview.jpg', fixture: 'sample.ogg' }
+        const attributes = { name: 'audio_with_preview', previewfile: 'custom-preview.jpg', fixture: 'sample.ogg' }
         await servers[1].videos.upload({ attributes, mode })
 
         await waitJobs(servers)
@@ -405,7 +405,7 @@ describe('Test video transcoding', function () {
           newConfig: {
             transcoding: {
               hls: { enabled: true },
-              webtorrent: { enabled: true },
+              webVideos: { enabled: true },
               resolutions: {
                 '0p': true,
                 '144p': false,
@@ -416,7 +416,7 @@ describe('Test video transcoding', function () {
           }
         })
 
-        const attributes = { name: 'audio_with_preview', previewfile: 'preview.jpg', fixture: 'sample.ogg' }
+        const attributes = { name: 'audio_with_preview', previewfile: 'custom-preview.jpg', fixture: 'sample.ogg' }
         const { id } = await servers[1].videos.upload({ attributes, mode })
 
         await waitJobs(servers)
@@ -472,14 +472,14 @@ describe('Test video transcoding', function () {
 
         for (const resolution of [ 144, 240, 360, 480 ]) {
           const file = videoDetails.files.find(f => f.resolution.id === resolution)
-          const path = servers[1].servers.buildWebTorrentFilePath(file.fileUrl)
+          const path = servers[1].servers.buildWebVideoFilePath(file.fileUrl)
           const fps = await getVideoStreamFPS(path)
 
           expect(fps).to.be.below(31)
         }
 
         const file = videoDetails.files.find(f => f.resolution.id === 720)
-        const path = servers[1].servers.buildWebTorrentFilePath(file.fileUrl)
+        const path = servers[1].servers.buildWebVideoFilePath(file.fileUrl)
         const fps = await getVideoStreamFPS(path)
 
         expect(fps).to.be.above(58).and.below(62)
@@ -516,14 +516,14 @@ describe('Test video transcoding', function () {
 
         {
           const file = video.files.find(f => f.resolution.id === 240)
-          const path = servers[1].servers.buildWebTorrentFilePath(file.fileUrl)
+          const path = servers[1].servers.buildWebVideoFilePath(file.fileUrl)
           const fps = await getVideoStreamFPS(path)
           expect(fps).to.be.equal(25)
         }
 
         {
           const file = video.files.find(f => f.resolution.id === 720)
-          const path = servers[1].servers.buildWebTorrentFilePath(file.fileUrl)
+          const path = servers[1].servers.buildWebVideoFilePath(file.fileUrl)
           const fps = await getVideoStreamFPS(path)
           expect(fps).to.be.equal(59)
         }
@@ -556,7 +556,7 @@ describe('Test video transcoding', function () {
 
         for (const resolution of [ 240, 360, 480, 720, 1080 ]) {
           const file = video.files.find(f => f.resolution.id === resolution)
-          const path = servers[1].servers.buildWebTorrentFilePath(file.fileUrl)
+          const path = servers[1].servers.buildWebVideoFilePath(file.fileUrl)
 
           const bitrate = await getVideoStreamBitrate(path)
           const fps = await getVideoStreamFPS(path)
@@ -586,7 +586,7 @@ describe('Test video transcoding', function () {
             '1440p': true,
             '2160p': true
           },
-          webtorrent: { enabled: true },
+          webVideos: { enabled: true },
           hls: { enabled: true }
         }
       }
@@ -607,7 +607,7 @@ describe('Test video transcoding', function () {
       for (const r of resolutions) {
         const file = video.files.find(f => f.resolution.id === r)
 
-        const path = servers[1].servers.buildWebTorrentFilePath(file.fileUrl)
+        const path = servers[1].servers.buildWebVideoFilePath(file.fileUrl)
         const bitrate = await getVideoStreamBitrate(path)
 
         const inputBitrate = 60_000
@@ -631,7 +631,7 @@ describe('Test video transcoding', function () {
       {
         const video = await servers[1].videos.get({ id: videoUUID })
         const file = video.files.find(f => f.resolution.id === 240)
-        const path = servers[1].servers.buildWebTorrentFilePath(file.fileUrl)
+        const path = servers[1].servers.buildWebVideoFilePath(file.fileUrl)
 
         const probe = await ffprobePromise(path)
         const metadata = new VideoFileMetadata(probe)
@@ -704,14 +704,14 @@ describe('Test video transcoding', function () {
       expect(transcodingJobs).to.have.lengthOf(16)
 
       const hlsJobs = transcodingJobs.filter(j => j.data.type === 'new-resolution-to-hls')
-      const webtorrentJobs = transcodingJobs.filter(j => j.data.type === 'new-resolution-to-webtorrent')
-      const optimizeJobs = transcodingJobs.filter(j => j.data.type === 'optimize-to-webtorrent')
+      const webVideoJobs = transcodingJobs.filter(j => j.data.type === 'new-resolution-to-web-video')
+      const optimizeJobs = transcodingJobs.filter(j => j.data.type === 'optimize-to-web-video')
 
       expect(hlsJobs).to.have.lengthOf(8)
-      expect(webtorrentJobs).to.have.lengthOf(7)
+      expect(webVideoJobs).to.have.lengthOf(7)
       expect(optimizeJobs).to.have.lengthOf(1)
 
-      for (const j of optimizeJobs.concat(hlsJobs.concat(webtorrentJobs))) {
+      for (const j of optimizeJobs.concat(hlsJobs.concat(webVideoJobs))) {
         expect(j.priority).to.be.greaterThan(100)
         expect(j.priority).to.be.lessThan(150)
       }
@@ -728,7 +728,7 @@ describe('Test video transcoding', function () {
           transcoding: {
             enabled: true,
             hls: { enabled: true },
-            webtorrent: { enabled: true },
+            webVideos: { enabled: true },
             resolutions: {
               '0p': false,
               '144p': false,
diff --git a/server/tests/api/transcoding/update-while-transcoding.ts b/server/tests/api/transcoding/update-while-transcoding.ts
index 61655f102..cfb4fa0cc 100644
--- a/server/tests/api/transcoding/update-while-transcoding.ts
+++ b/server/tests/api/transcoding/update-while-transcoding.ts
@@ -96,7 +96,7 @@ describe('Test update video privacy while transcoding', function () {
     await doubleFollow(servers[0], servers[1])
   })
 
-  describe('With WebTorrent & HLS enabled', function () {
+  describe('With Web Video & HLS enabled', function () {
     runTestSuite(false)
   })
 
@@ -121,7 +121,7 @@ describe('Test update video privacy while transcoding', function () {
             hls: {
               enabled: true
             },
-            webtorrent: {
+            webVideos: {
               enabled: false
             }
           }
diff --git a/server/tests/api/transcoding/video-studio.ts b/server/tests/api/transcoding/video-studio.ts
index d1298caf7..ba68f8e24 100644
--- a/server/tests/api/transcoding/video-studio.ts
+++ b/server/tests/api/transcoding/video-studio.ts
@@ -241,7 +241,7 @@ describe('Test video studio', function () {
         {
           name: 'add-watermark',
           options: {
-            file: 'thumbnail.png'
+            file: 'custom-thumbnail.png'
           }
         }
       ])
@@ -273,11 +273,11 @@ describe('Test video studio', function () {
   describe('HLS only studio edition', function () {
 
     before(async function () {
-      // Disable webtorrent
+      // Disable Web Videos
       await servers[0].config.updateExistingSubConfig({
         newConfig: {
           transcoding: {
-            webtorrent: {
+            webVideos: {
               enabled: false
             }
           }
@@ -354,8 +354,8 @@ describe('Test video studio', function () {
           expect(oldFileUrls).to.not.include(f.fileUrl)
         }
 
-        for (const webtorrentFile of video.files) {
-          expectStartWith(webtorrentFile.fileUrl, objectStorage.getMockWebVideosBaseUrl())
+        for (const webVideoFile of video.files) {
+          expectStartWith(webVideoFile.fileUrl, objectStorage.getMockWebVideosBaseUrl())
         }
 
         for (const hlsFile of video.streamingPlaylists[0].files) {
diff --git a/server/tests/api/users/user-videos.ts b/server/tests/api/users/user-videos.ts
index 696949504..77226e48e 100644
--- a/server/tests/api/users/user-videos.ts
+++ b/server/tests/api/users/user-videos.ts
@@ -184,12 +184,12 @@ describe('Test user videos', function () {
       }
     })
 
-    it('Should disable webtorrent, enable HLS, and update my quota', async function () {
+    it('Should disable web videos, enable HLS, and update my quota', async function () {
       this.timeout(160000)
 
       {
         const config = await server.config.getCustomConfig()
-        config.transcoding.webtorrent.enabled = false
+        config.transcoding.webVideos.enabled = false
         config.transcoding.hls.enabled = true
         config.transcoding.enabled = true
         await server.config.updateCustomSubConfig({ newConfig: config })
diff --git a/server/tests/api/users/users.ts b/server/tests/api/users/users.ts
index 1c00f9a93..67ade1d0d 100644
--- a/server/tests/api/users/users.ts
+++ b/server/tests/api/users/users.ts
@@ -229,25 +229,13 @@ describe('Test users', function () {
     })
 
     it('Should be able to change the p2p attribute', async function () {
-      {
-        await server.users.updateMe({
-          token: userToken,
-          webTorrentEnabled: false
-        })
-
-        const user = await server.users.getMyInfo({ token: userToken })
-        expect(user.p2pEnabled).to.be.false
-      }
-
-      {
-        await server.users.updateMe({
-          token: userToken,
-          p2pEnabled: true
-        })
+      await server.users.updateMe({
+        token: userToken,
+        p2pEnabled: true
+      })
 
-        const user = await server.users.getMyInfo({ token: userToken })
-        expect(user.p2pEnabled).to.be.true
-      }
+      const user = await server.users.getMyInfo({ token: userToken })
+      expect(user.p2pEnabled).to.be.true
     })
 
     it('Should be able to change the email attribute', async function () {
diff --git a/server/tests/api/videos/index.ts b/server/tests/api/videos/index.ts
index 357c08199..9c79b3aa6 100644
--- a/server/tests/api/videos/index.ts
+++ b/server/tests/api/videos/index.ts
@@ -20,3 +20,4 @@ import './videos-history'
 import './videos-overview'
 import './video-source'
 import './video-static-file-privacy'
+import './video-storyboard'
diff --git a/server/tests/api/videos/multiple-servers.ts b/server/tests/api/videos/multiple-servers.ts
index 27ba00d3d..e9aa0e3a1 100644
--- a/server/tests/api/videos/multiple-servers.ts
+++ b/server/tests/api/videos/multiple-servers.ts
@@ -9,7 +9,7 @@ import {
   completeVideoCheck,
   dateIsValid,
   saveVideoInServers,
-  testImage
+  testImageGeneratedByFFmpeg
 } from '@server/tests/shared'
 import { buildAbsoluteFixturePath, wait } from '@shared/core-utils'
 import { HttpStatusCode, VideoCommentThreadTree, VideoPrivacy } from '@shared/models'
@@ -70,8 +70,9 @@ describe('Test multiple servers', function () {
   })
 
   describe('Should upload the video and propagate on each server', function () {
+
     it('Should upload the video on server 1 and propagate on each server', async function () {
-      this.timeout(25000)
+      this.timeout(60000)
 
       const attributes = {
         name: 'my super name for server 1',
@@ -175,8 +176,8 @@ describe('Test multiple servers', function () {
         support: 'my super support text for server 2',
         tags: [ 'tag1p2', 'tag2p2', 'tag3p2' ],
         fixture: 'video_short2.webm',
-        thumbnailfile: 'thumbnail.jpg',
-        previewfile: 'preview.jpg'
+        thumbnailfile: 'custom-thumbnail.jpg',
+        previewfile: 'custom-preview.jpg'
       }
       await servers[1].videos.upload({ token: userAccessToken, attributes, mode: 'resumable' })
 
@@ -229,8 +230,8 @@ describe('Test multiple servers', function () {
               size: 750000
             }
           ],
-          thumbnailfile: 'thumbnail',
-          previewfile: 'preview'
+          thumbnailfile: 'custom-thumbnail',
+          previewfile: 'custom-preview'
         }
 
         const { data } = await server.videos.list()
@@ -619,9 +620,9 @@ describe('Test multiple servers', function () {
         description: 'my super description updated',
         support: 'my super support text updated',
         tags: [ 'tag_up_1', 'tag_up_2' ],
-        thumbnailfile: 'thumbnail.jpg',
+        thumbnailfile: 'custom-thumbnail.jpg',
         originallyPublishedAt: '2019-02-11T13:38:14.449Z',
-        previewfile: 'preview.jpg'
+        previewfile: 'custom-preview.jpg'
       }
 
       updatedAtMin = new Date()
@@ -674,8 +675,8 @@ describe('Test multiple servers', function () {
               size: 292677
             }
           ],
-          thumbnailfile: 'thumbnail',
-          previewfile: 'preview'
+          thumbnailfile: 'custom-thumbnail',
+          previewfile: 'custom-preview'
         }
         await completeVideoCheck({ server, originServer: servers[2], videoUUID: videoUpdated.uuid, attributes: checkAttributes })
       }
@@ -685,7 +686,7 @@ describe('Test multiple servers', function () {
       this.timeout(30000)
 
       const attributes = {
-        thumbnailfile: 'thumbnail.jpg'
+        thumbnailfile: 'custom-thumbnail.jpg'
       }
 
       updatedAtMin = new Date()
@@ -761,7 +762,7 @@ describe('Test multiple servers', function () {
       for (const server of servers) {
         const video = await server.videos.get({ id: videoUUID })
 
-        await testImage(server.url, 'video_short1-preview.webm', video.previewPath)
+        await testImageGeneratedByFFmpeg(server.url, 'video_short1-preview.webm', video.previewPath)
       }
     })
   })
diff --git a/server/tests/api/videos/resumable-upload.ts b/server/tests/api/videos/resumable-upload.ts
index 2fbefb392..91eb61833 100644
--- a/server/tests/api/videos/resumable-upload.ts
+++ b/server/tests/api/videos/resumable-upload.ts
@@ -93,10 +93,10 @@ describe('Test resumable upload', function () {
     expect((await stat(filePath)).size).to.equal(expectedSize)
   }
 
-  async function countResumableUploads () {
+  async function countResumableUploads (wait?: number) {
     const subPath = join('tmp', 'resumable-uploads')
     const filePath = server.servers.buildDirectory(subPath)
-
+    await new Promise(resolve => setTimeout(resolve, wait))
     const files = await readdir(filePath)
     return files.length
   }
@@ -122,14 +122,20 @@ describe('Test resumable upload', function () {
 
   describe('Directory cleaning', function () {
 
-    // FIXME: https://github.com/kukhariev/node-uploadx/pull/524/files#r852989382
-    // it('Should correctly delete files after an upload', async function () {
-    //   const uploadId = await prepareUpload()
-    //   await sendChunks({ pathUploadId: uploadId })
-    //   await server.videos.endResumableUpload({ pathUploadId: uploadId })
+    it('Should correctly delete files after an upload', async function () {
+      const uploadId = await prepareUpload()
+      await sendChunks({ pathUploadId: uploadId })
+      await server.videos.endResumableUpload({ pathUploadId: uploadId })
+
+      expect(await countResumableUploads()).to.equal(0)
+    })
+
+    it('Should correctly delete corrupt files', async function () {
+      const uploadId = await prepareUpload({ size: 8 * 1024 })
+      await sendChunks({ pathUploadId: uploadId, size: 8 * 1024, expectedStatus: HttpStatusCode.UNPROCESSABLE_ENTITY_422 })
 
-    //   expect(await countResumableUploads()).to.equal(0)
-    // })
+      expect(await countResumableUploads(2000)).to.equal(0)
+    })
 
     it('Should not delete files after an unfinished upload', async function () {
       await prepareUpload()
@@ -254,6 +260,24 @@ describe('Test resumable upload', function () {
       expect(result2.headers['x-resumable-upload-cached']).to.not.exist
     })
 
+    it('Should not cache after video deletion', async function () {
+      const originalName = 'toto.mp4'
+      const lastModified = new Date().getTime()
+
+      const uploadId1 = await prepareUpload({ originalName, lastModified })
+      const result1 = await sendChunks({ pathUploadId: uploadId1 })
+      await server.videos.remove({ id: result1.body.video.uuid })
+
+      const uploadId2 = await prepareUpload({ originalName, lastModified })
+      const result2 = await sendChunks({ pathUploadId: uploadId2 })
+      expect(result1.body.video.uuid).to.not.equal(result2.body.video.uuid)
+
+      expect(result2.headers['x-resumable-upload-cached']).to.not.exist
+
+      await checkFileSize(uploadId1, null)
+      await checkFileSize(uploadId2, null)
+    })
+
     it('Should refuse an invalid digest', async function () {
       const uploadId = await prepareUpload({ token: server.accessToken })
 
diff --git a/server/tests/api/videos/single-server.ts b/server/tests/api/videos/single-server.ts
index 0cb64d5a5..66414aa5b 100644
--- a/server/tests/api/videos/single-server.ts
+++ b/server/tests/api/videos/single-server.ts
@@ -1,7 +1,7 @@
 /* eslint-disable @typescript-eslint/no-unused-expressions,@typescript-eslint/require-await */
 
 import { expect } from 'chai'
-import { checkVideoFilesWereRemoved, completeVideoCheck, testImage } from '@server/tests/shared'
+import { checkVideoFilesWereRemoved, completeVideoCheck, testImageGeneratedByFFmpeg } from '@server/tests/shared'
 import { wait } from '@shared/core-utils'
 import { Video, VideoPrivacy } from '@shared/models'
 import {
@@ -260,7 +260,7 @@ describe('Test a single server', function () {
 
       for (const video of data) {
         const videoName = video.name.replace(' name', '')
-        await testImage(server.url, videoName, video.thumbnailPath)
+        await testImageGeneratedByFFmpeg(server.url, videoName, video.thumbnailPath)
       }
     })
 
diff --git a/server/tests/api/videos/video-files.ts b/server/tests/api/videos/video-files.ts
index 8c913bf31..0a183c44d 100644
--- a/server/tests/api/videos/video-files.ts
+++ b/server/tests/api/videos/video-files.ts
@@ -48,10 +48,10 @@ describe('Test videos files', function () {
       await waitJobs(servers)
     })
 
-    it('Should delete webtorrent files', async function () {
+    it('Should delete web video files', async function () {
       this.timeout(30_000)
 
-      await servers[0].videos.removeAllWebTorrentFiles({ videoId: validId1 })
+      await servers[0].videos.removeAllWebVideoFiles({ videoId: validId1 })
 
       await waitJobs(servers)
 
@@ -80,15 +80,15 @@ describe('Test videos files', function () {
   })
 
   describe('When deleting a specific file', function () {
-    let webtorrentId: string
+    let webVideoId: string
     let hlsId: string
 
     before(async function () {
       this.timeout(120_000)
 
       {
-        const { uuid } = await servers[0].videos.quickUpload({ name: 'webtorrent' })
-        webtorrentId = uuid
+        const { uuid } = await servers[0].videos.quickUpload({ name: 'web-video' })
+        webVideoId = uuid
       }
 
       {
@@ -99,38 +99,38 @@ describe('Test videos files', function () {
       await waitJobs(servers)
     })
 
-    it('Shoulde delete a webtorrent file', async function () {
+    it('Shoulde delete a web video file', async function () {
       this.timeout(30_000)
 
-      const video = await servers[0].videos.get({ id: webtorrentId })
+      const video = await servers[0].videos.get({ id: webVideoId })
       const files = video.files
 
-      await servers[0].videos.removeWebTorrentFile({ videoId: webtorrentId, fileId: files[0].id })
+      await servers[0].videos.removeWebVideoFile({ videoId: webVideoId, fileId: files[0].id })
 
       await waitJobs(servers)
 
       for (const server of servers) {
-        const video = await server.videos.get({ id: webtorrentId })
+        const video = await server.videos.get({ id: webVideoId })
 
         expect(video.files).to.have.lengthOf(files.length - 1)
         expect(video.files.find(f => f.id === files[0].id)).to.not.exist
       }
     })
 
-    it('Should delete all webtorrent files', async function () {
+    it('Should delete all web video files', async function () {
       this.timeout(30_000)
 
-      const video = await servers[0].videos.get({ id: webtorrentId })
+      const video = await servers[0].videos.get({ id: webVideoId })
       const files = video.files
 
       for (const file of files) {
-        await servers[0].videos.removeWebTorrentFile({ videoId: webtorrentId, fileId: file.id })
+        await servers[0].videos.removeWebVideoFile({ videoId: webVideoId, fileId: file.id })
       }
 
       await waitJobs(servers)
 
       for (const server of servers) {
-        const video = await server.videos.get({ id: webtorrentId })
+        const video = await server.videos.get({ id: webVideoId })
 
         expect(video.files).to.have.lengthOf(0)
       }
@@ -182,16 +182,16 @@ describe('Test videos files', function () {
     it('Should not delete last file of a video', async function () {
       this.timeout(60_000)
 
-      const webtorrentOnly = await servers[0].videos.get({ id: hlsId })
-      const hlsOnly = await servers[0].videos.get({ id: webtorrentId })
+      const webVideoOnly = await servers[0].videos.get({ id: hlsId })
+      const hlsOnly = await servers[0].videos.get({ id: webVideoId })
 
       for (let i = 0; i < 4; i++) {
-        await servers[0].videos.removeWebTorrentFile({ videoId: webtorrentOnly.id, fileId: webtorrentOnly.files[i].id })
+        await servers[0].videos.removeWebVideoFile({ videoId: webVideoOnly.id, fileId: webVideoOnly.files[i].id })
         await servers[0].videos.removeHLSFile({ videoId: hlsOnly.id, fileId: hlsOnly.streamingPlaylists[0].files[i].id })
       }
 
       const expectedStatus = HttpStatusCode.BAD_REQUEST_400
-      await servers[0].videos.removeWebTorrentFile({ videoId: webtorrentOnly.id, fileId: webtorrentOnly.files[4].id, expectedStatus })
+      await servers[0].videos.removeWebVideoFile({ videoId: webVideoOnly.id, fileId: webVideoOnly.files[4].id, expectedStatus })
       await servers[0].videos.removeHLSFile({ videoId: hlsOnly.id, fileId: hlsOnly.streamingPlaylists[0].files[4].id, expectedStatus })
     })
   })
diff --git a/server/tests/api/videos/video-imports.ts b/server/tests/api/videos/video-imports.ts
index 192b2aeb9..b78b4f344 100644
--- a/server/tests/api/videos/video-imports.ts
+++ b/server/tests/api/videos/video-imports.ts
@@ -3,7 +3,7 @@
 import { expect } from 'chai'
 import { pathExists, readdir, remove } from 'fs-extra'
 import { join } from 'path'
-import { FIXTURE_URLS, testCaptionFile, testImage } from '@server/tests/shared'
+import { FIXTURE_URLS, testCaptionFile, testImageGeneratedByFFmpeg } from '@server/tests/shared'
 import { areHttpImportTestsDisabled } from '@shared/core-utils'
 import { CustomConfig, HttpStatusCode, Video, VideoImportState, VideoPrivacy, VideoResolution, VideoState } from '@shared/models'
 import {
@@ -67,7 +67,7 @@ async function checkVideoServer2 (server: PeerTubeServer, id: number | string) {
   expect(video.description).to.equal('my super description')
   expect(video.tags).to.deep.equal([ 'supertag1', 'supertag2' ])
 
-  await testImage(server.url, 'thumbnail', video.thumbnailPath)
+  await testImageGeneratedByFFmpeg(server.url, 'custom-thumbnail', video.thumbnailPath)
 
   expect(video.files).to.have.lengthOf(1)
 
@@ -119,15 +119,15 @@ describe('Test video imports', function () {
           expect(video.name).to.equal('small video - youtube')
 
           {
-            expect(video.thumbnailPath).to.match(new RegExp(`^/static/thumbnails/.+.jpg$`))
+            expect(video.thumbnailPath).to.match(new RegExp(`^/lazy-static/thumbnails/.+.jpg$`))
             expect(video.previewPath).to.match(new RegExp(`^/lazy-static/previews/.+.jpg$`))
 
             const suffix = mode === 'yt-dlp'
               ? '_yt_dlp'
               : ''
 
-            await testImage(servers[0].url, 'video_import_thumbnail' + suffix, video.thumbnailPath)
-            await testImage(servers[0].url, 'video_import_preview' + suffix, video.previewPath)
+            await testImageGeneratedByFFmpeg(servers[0].url, 'video_import_thumbnail' + suffix, video.thumbnailPath)
+            await testImageGeneratedByFFmpeg(servers[0].url, 'video_import_preview' + suffix, video.previewPath)
           }
 
           const bodyCaptions = await servers[0].captions.list({ videoId: video.id })
@@ -266,7 +266,7 @@ describe('Test video imports', function () {
             name: 'my super name',
             description: 'my super description',
             tags: [ 'supertag1', 'supertag2' ],
-            thumbnailfile: 'thumbnail.jpg'
+            thumbnailfile: 'custom-thumbnail.jpg'
           }
         })
         expect(video.name).to.equal('my super name')
@@ -328,7 +328,7 @@ describe('Test video imports', function () {
               '1440p': false,
               '2160p': false
             },
-            webtorrent: { enabled: true },
+            webVideos: { enabled: true },
             hls: { enabled: false }
           }
         }
diff --git a/server/tests/api/videos/video-passwords.ts b/server/tests/api/videos/video-passwords.ts
new file mode 100644
index 000000000..e01a93a4d
--- /dev/null
+++ b/server/tests/api/videos/video-passwords.ts
@@ -0,0 +1,97 @@
+/* eslint-disable @typescript-eslint/no-unused-expressions,@typescript-eslint/require-await */
+
+import { expect } from 'chai'
+import {
+  cleanupTests,
+  createSingleServer,
+  VideoPasswordsCommand,
+  PeerTubeServer,
+  setAccessTokensToServers,
+  setDefaultAccountAvatar,
+  setDefaultChannelAvatar
+} from '@shared/server-commands'
+import { VideoPrivacy } from '@shared/models'
+
+describe('Test video passwords', function () {
+  let server: PeerTubeServer
+  let videoUUID: string
+
+  let userAccessTokenServer1: string
+
+  let videoPasswords: string[] = []
+  let command: VideoPasswordsCommand
+
+  before(async function () {
+    this.timeout(30000)
+
+    server = await createSingleServer(1)
+
+    await setAccessTokensToServers([ server ])
+
+    for (let i = 0; i < 10; i++) {
+      videoPasswords.push(`password ${i + 1}`)
+    }
+    const { uuid } = await server.videos.upload({ attributes: { privacy: VideoPrivacy.PASSWORD_PROTECTED, videoPasswords } })
+    videoUUID = uuid
+
+    await setDefaultChannelAvatar(server)
+    await setDefaultAccountAvatar(server)
+
+    userAccessTokenServer1 = await server.users.generateUserAndToken('user1')
+    await setDefaultChannelAvatar(server, 'user1_channel')
+    await setDefaultAccountAvatar(server, userAccessTokenServer1)
+
+    command = server.videoPasswords
+  })
+
+  it('Should list video passwords', async function () {
+    const body = await command.list({ videoId: videoUUID })
+
+    expect(body.total).to.equal(10)
+    expect(body.data).to.be.an('array')
+    expect(body.data).to.have.lengthOf(10)
+  })
+
+  it('Should filter passwords on this video', async function () {
+    const body = await command.list({ videoId: videoUUID, count: 2, start: 3, sort: 'createdAt' })
+
+    expect(body.total).to.equal(10)
+    expect(body.data).to.be.an('array')
+    expect(body.data).to.have.lengthOf(2)
+    expect(body.data[0].password).to.equal('password 4')
+    expect(body.data[1].password).to.equal('password 5')
+  })
+
+  it('Should update password for this video', async function () {
+    videoPasswords = [ 'my super new password 1', 'my super new password 2' ]
+
+    await command.updateAll({ videoId: videoUUID, passwords: videoPasswords })
+    const body = await command.list({ videoId: videoUUID })
+    expect(body.total).to.equal(2)
+    expect(body.data).to.be.an('array')
+    expect(body.data).to.have.lengthOf(2)
+    expect(body.data[0].password).to.equal('my super new password 2')
+    expect(body.data[1].password).to.equal('my super new password 1')
+  })
+
+  it('Should delete one password', async function () {
+    {
+      const body = await command.list({ videoId: videoUUID })
+      expect(body.total).to.equal(2)
+      expect(body.data).to.be.an('array')
+      expect(body.data).to.have.lengthOf(2)
+      await command.remove({ id: body.data[0].id, videoId: videoUUID })
+    }
+    {
+      const body = await command.list({ videoId: videoUUID })
+
+      expect(body.total).to.equal(1)
+      expect(body.data).to.be.an('array')
+      expect(body.data).to.have.lengthOf(1)
+    }
+  })
+
+  after(async function () {
+    await cleanupTests([ server ])
+  })
+})
diff --git a/server/tests/api/videos/video-playlist-thumbnails.ts b/server/tests/api/videos/video-playlist-thumbnails.ts
index 356939b93..c274c20bf 100644
--- a/server/tests/api/videos/video-playlist-thumbnails.ts
+++ b/server/tests/api/videos/video-playlist-thumbnails.ts
@@ -1,7 +1,7 @@
 /* eslint-disable @typescript-eslint/no-unused-expressions,@typescript-eslint/require-await */
 
 import { expect } from 'chai'
-import { testImage } from '@server/tests/shared'
+import { testImageGeneratedByFFmpeg } from '@server/tests/shared'
 import { VideoPlaylistPrivacy } from '@shared/models'
 import {
   cleanupTests,
@@ -83,7 +83,7 @@ describe('Playlist thumbnail', function () {
 
     for (const server of servers) {
       const p = await getPlaylistWithoutThumbnail(server)
-      await testImage(server.url, 'thumbnail-playlist', p.thumbnailPath)
+      await testImageGeneratedByFFmpeg(server.url, 'thumbnail-playlist', p.thumbnailPath)
     }
   })
 
@@ -95,7 +95,7 @@ describe('Playlist thumbnail', function () {
         displayName: 'playlist with thumbnail',
         privacy: VideoPlaylistPrivacy.PUBLIC,
         videoChannelId: servers[1].store.channel.id,
-        thumbnailfile: 'thumbnail.jpg'
+        thumbnailfile: 'custom-thumbnail.jpg'
       }
     })
     playlistWithThumbnailId = created.id
@@ -110,7 +110,7 @@ describe('Playlist thumbnail', function () {
 
     for (const server of servers) {
       const p = await getPlaylistWithThumbnail(server)
-      await testImage(server.url, 'thumbnail', p.thumbnailPath)
+      await testImageGeneratedByFFmpeg(server.url, 'custom-thumbnail', p.thumbnailPath)
     }
   })
 
@@ -135,7 +135,7 @@ describe('Playlist thumbnail', function () {
 
     for (const server of servers) {
       const p = await getPlaylistWithoutThumbnail(server)
-      await testImage(server.url, 'thumbnail-playlist', p.thumbnailPath)
+      await testImageGeneratedByFFmpeg(server.url, 'thumbnail-playlist', p.thumbnailPath)
     }
   })
 
@@ -160,7 +160,7 @@ describe('Playlist thumbnail', function () {
 
     for (const server of servers) {
       const p = await getPlaylistWithThumbnail(server)
-      await testImage(server.url, 'thumbnail', p.thumbnailPath)
+      await testImageGeneratedByFFmpeg(server.url, 'custom-thumbnail', p.thumbnailPath)
     }
   })
 
@@ -176,7 +176,7 @@ describe('Playlist thumbnail', function () {
 
     for (const server of servers) {
       const p = await getPlaylistWithoutThumbnail(server)
-      await testImage(server.url, 'thumbnail-playlist', p.thumbnailPath)
+      await testImageGeneratedByFFmpeg(server.url, 'thumbnail-playlist', p.thumbnailPath)
     }
   })
 
@@ -192,7 +192,7 @@ describe('Playlist thumbnail', function () {
 
     for (const server of servers) {
       const p = await getPlaylistWithThumbnail(server)
-      await testImage(server.url, 'thumbnail', p.thumbnailPath)
+      await testImageGeneratedByFFmpeg(server.url, 'custom-thumbnail', p.thumbnailPath)
     }
   })
 
@@ -224,7 +224,7 @@ describe('Playlist thumbnail', function () {
 
     for (const server of servers) {
       const p = await getPlaylistWithThumbnail(server)
-      await testImage(server.url, 'thumbnail', p.thumbnailPath)
+      await testImageGeneratedByFFmpeg(server.url, 'custom-thumbnail', p.thumbnailPath)
     }
   })
 
diff --git a/server/tests/api/videos/video-playlists.ts b/server/tests/api/videos/video-playlists.ts
index d9c5bdf16..3bfa874cb 100644
--- a/server/tests/api/videos/video-playlists.ts
+++ b/server/tests/api/videos/video-playlists.ts
@@ -1,7 +1,7 @@
 /* eslint-disable @typescript-eslint/no-unused-expressions,@typescript-eslint/require-await */
 
 import { expect } from 'chai'
-import { checkPlaylistFilesWereRemoved, testImage } from '@server/tests/shared'
+import { checkPlaylistFilesWereRemoved, testImageGeneratedByFFmpeg } from '@server/tests/shared'
 import { wait } from '@shared/core-utils'
 import { uuidToShort } from '@shared/extra-utils'
 import {
@@ -133,7 +133,7 @@ describe('Test video playlists', function () {
           displayName: 'my super playlist',
           privacy: VideoPlaylistPrivacy.PUBLIC,
           description: 'my super description',
-          thumbnailfile: 'thumbnail.jpg',
+          thumbnailfile: 'custom-thumbnail.jpg',
           videoChannelId: servers[0].store.channel.id
         }
       })
@@ -225,7 +225,7 @@ describe('Test video playlists', function () {
           displayName: 'my super playlist',
           privacy: VideoPlaylistPrivacy.PUBLIC,
           description: 'my super description',
-          thumbnailfile: 'thumbnail.jpg',
+          thumbnailfile: 'custom-thumbnail.jpg',
           videoChannelId: servers[0].store.channel.id
         }
       })
@@ -286,7 +286,7 @@ describe('Test video playlists', function () {
           attributes: {
             displayName: 'playlist 3',
             privacy: VideoPlaylistPrivacy.PUBLIC,
-            thumbnailfile: 'thumbnail.jpg',
+            thumbnailfile: 'custom-thumbnail.jpg',
             videoChannelId: servers[1].store.channel.id
           }
         })
@@ -314,11 +314,11 @@ describe('Test video playlists', function () {
 
         const playlist2 = body.data.find(p => p.displayName === 'playlist 2')
         expect(playlist2).to.not.be.undefined
-        await testImage(server.url, 'thumbnail-playlist', playlist2.thumbnailPath)
+        await testImageGeneratedByFFmpeg(server.url, 'thumbnail-playlist', playlist2.thumbnailPath)
 
         const playlist3 = body.data.find(p => p.displayName === 'playlist 3')
         expect(playlist3).to.not.be.undefined
-        await testImage(server.url, 'thumbnail', playlist3.thumbnailPath)
+        await testImageGeneratedByFFmpeg(server.url, 'custom-thumbnail', playlist3.thumbnailPath)
       }
 
       const body = await servers[2].playlists.list({ start: 0, count: 5 })
@@ -336,7 +336,7 @@ describe('Test video playlists', function () {
 
       const playlist2 = body.data.find(p => p.displayName === 'playlist 2')
       expect(playlist2).to.not.be.undefined
-      await testImage(servers[2].url, 'thumbnail-playlist', playlist2.thumbnailPath)
+      await testImageGeneratedByFFmpeg(servers[2].url, 'thumbnail-playlist', playlist2.thumbnailPath)
 
       expect(body.data.find(p => p.displayName === 'playlist 3')).to.not.be.undefined
     })
@@ -474,7 +474,7 @@ describe('Test video playlists', function () {
       await servers[1].playlists.get({ playlistId: unlistedPlaylist.id, expectedStatus: 404 })
     })
 
-    it('Should get unlisted plyaylist using uuid or shortUUID', async function () {
+    it('Should get unlisted playlist using uuid or shortUUID', async function () {
       await servers[1].playlists.get({ playlistId: unlistedPlaylist.uuid })
       await servers[1].playlists.get({ playlistId: unlistedPlaylist.shortUUID })
     })
@@ -502,7 +502,7 @@ describe('Test video playlists', function () {
           displayName: 'playlist 3 updated',
           description: 'description updated',
           privacy: VideoPlaylistPrivacy.UNLISTED,
-          thumbnailfile: 'thumbnail.jpg',
+          thumbnailfile: 'custom-thumbnail.jpg',
           videoChannelId: servers[1].store.channel.id
         },
         playlistId: playlistServer2Id2
@@ -686,7 +686,7 @@ describe('Test video playlists', function () {
       await waitJobs(servers)
     })
 
-    it('Should update the element type if the video is private', async function () {
+    it('Should update the element type if the video is private/password protected', async function () {
       this.timeout(20000)
 
       const name = 'video 89'
@@ -703,6 +703,19 @@ describe('Test video playlists', function () {
       }
 
       {
+        await servers[0].videos.update({
+          id: video1,
+          attributes: { privacy: VideoPrivacy.PASSWORD_PROTECTED, videoPasswords: [ 'password' ] }
+        })
+        await waitJobs(servers)
+
+        await checkPlaylistElementType(groupUser1, playlistServer1UUID2, VideoPlaylistElementType.REGULAR, position, name, 3)
+        await checkPlaylistElementType(groupWithoutToken1, playlistServer1UUID2, VideoPlaylistElementType.PRIVATE, position, name, 3)
+        await checkPlaylistElementType(group1, playlistServer1UUID2, VideoPlaylistElementType.PRIVATE, position, name, 3)
+        await checkPlaylistElementType(group2, playlistServer1UUID2, VideoPlaylistElementType.DELETED, position, name, 3)
+      }
+
+      {
         await servers[0].videos.update({ id: video1, attributes: { privacy: VideoPrivacy.PUBLIC } })
         await waitJobs(servers)
 
diff --git a/server/tests/api/videos/video-static-file-privacy.ts b/server/tests/api/videos/video-static-file-privacy.ts
index 542848533..0a9864134 100644
--- a/server/tests/api/videos/video-static-file-privacy.ts
+++ b/server/tests/api/videos/video-static-file-privacy.ts
@@ -41,7 +41,7 @@ describe('Test video static file privacy', function () {
 
         for (const file of video.files) {
           expect(file.fileDownloadUrl).to.not.include('/private/')
-          expectStartWith(file.fileUrl, server.url + '/static/webseed/private/')
+          expectStartWith(file.fileUrl, server.url + '/static/web-videos/private/')
 
           const torrent = await parseTorrentVideo(server, file)
           expect(torrent.urlList).to.have.lengthOf(0)
@@ -90,7 +90,7 @@ describe('Test video static file privacy', function () {
         }
       }
 
-      it('Should upload a private/internal video and have a private static path', async function () {
+      it('Should upload a private/internal/password protected video and have a private static path', async function () {
         this.timeout(120000)
 
         for (const privacy of [ VideoPrivacy.PRIVATE, VideoPrivacy.INTERNAL ]) {
@@ -99,6 +99,15 @@ describe('Test video static file privacy', function () {
 
           await checkPrivateFiles(uuid)
         }
+
+        const { uuid } = await server.videos.quickUpload({
+          name: 'video',
+          privacy: VideoPrivacy.PASSWORD_PROTECTED,
+          videoPasswords: [ 'my super password' ]
+        })
+        await waitJobs([ server ])
+
+        await checkPrivateFiles(uuid)
       })
 
       it('Should upload a public video and update it as private/internal to have a private static path', async function () {
@@ -185,8 +194,9 @@ describe('Test video static file privacy', function () {
       expectedStatus: HttpStatusCode
       token: string
       videoFileToken: string
+      videoPassword?: string
     }) {
-      const { id, expectedStatus, token, videoFileToken } = options
+      const { id, expectedStatus, token, videoFileToken, videoPassword } = options
 
       const video = await server.videos.getWithToken({ id })
 
@@ -196,6 +206,12 @@ describe('Test video static file privacy', function () {
 
         await makeRawRequest({ url: file.fileUrl, query: { videoFileToken }, expectedStatus })
         await makeRawRequest({ url: file.fileDownloadUrl, query: { videoFileToken }, expectedStatus })
+
+        if (videoPassword) {
+          const headers = { 'x-peertube-video-password': videoPassword }
+          await makeRawRequest({ url: file.fileUrl, headers, expectedStatus })
+          await makeRawRequest({ url: file.fileDownloadUrl, headers, expectedStatus })
+        }
       }
 
       const hls = video.streamingPlaylists[0]
@@ -204,6 +220,12 @@ describe('Test video static file privacy', function () {
 
       await makeRawRequest({ url: hls.playlistUrl, query: { videoFileToken }, expectedStatus })
       await makeRawRequest({ url: hls.segmentsSha256Url, query: { videoFileToken }, expectedStatus })
+
+      if (videoPassword) {
+        const headers = { 'x-peertube-video-password': videoPassword }
+        await makeRawRequest({ url: hls.playlistUrl, token: null, headers, expectedStatus })
+        await makeRawRequest({ url: hls.segmentsSha256Url, token: null, headers, expectedStatus })
+      }
     }
 
     before(async function () {
@@ -216,13 +238,53 @@ describe('Test video static file privacy', function () {
     it('Should not be able to access a private video files without OAuth token and file token', async function () {
       this.timeout(120000)
 
-      const { uuid } = await server.videos.quickUpload({ name: 'video', privacy: VideoPrivacy.INTERNAL })
+      const { uuid } = await server.videos.quickUpload({ name: 'video', privacy: VideoPrivacy.PRIVATE })
       await waitJobs([ server ])
 
       await checkVideoFiles({ id: uuid, expectedStatus: HttpStatusCode.FORBIDDEN_403, token: null, videoFileToken: null })
     })
 
-    it('Should not be able to access an internal video files without appropriate OAuth token and file token', async function () {
+    it('Should not be able to access password protected video files without OAuth token, file token and password', async function () {
+      this.timeout(120000)
+      const videoPassword = 'my super password'
+
+      const { uuid } = await server.videos.quickUpload({
+        name: 'password protected video',
+        privacy: VideoPrivacy.PASSWORD_PROTECTED,
+        videoPasswords: [ videoPassword ]
+      })
+      await waitJobs([ server ])
+
+      await checkVideoFiles({
+        id: uuid,
+        expectedStatus: HttpStatusCode.FORBIDDEN_403,
+        token: null,
+        videoFileToken: null,
+        videoPassword: null
+      })
+    })
+
+    it('Should not be able to access an password video files with incorrect OAuth token, file token and password', async function () {
+      this.timeout(120000)
+      const videoPassword = 'my super password'
+
+      const { uuid } = await server.videos.quickUpload({
+        name: 'password protected video',
+        privacy: VideoPrivacy.PASSWORD_PROTECTED,
+        videoPasswords: [ videoPassword ]
+      })
+      await waitJobs([ server ])
+
+      await checkVideoFiles({
+        id: uuid,
+        expectedStatus: HttpStatusCode.FORBIDDEN_403,
+        token: userToken,
+        videoFileToken: unrelatedFileToken,
+        videoPassword: 'incorrectPassword'
+      })
+    })
+
+    it('Should not be able to access an private video files without appropriate OAuth token and file token', async function () {
       this.timeout(120000)
 
       const { uuid } = await server.videos.quickUpload({ name: 'video', privacy: VideoPrivacy.PRIVATE })
@@ -247,6 +309,23 @@ describe('Test video static file privacy', function () {
       await checkVideoFiles({ id: uuid, expectedStatus: HttpStatusCode.OK_200, token: server.accessToken, videoFileToken })
     })
 
+    it('Should be able to access a password protected video files with appropriate OAuth token or file token', async function () {
+      this.timeout(120000)
+      const videoPassword = 'my super password'
+
+      const { uuid } = await server.videos.quickUpload({
+        name: 'video',
+        privacy: VideoPrivacy.PASSWORD_PROTECTED,
+        videoPasswords: [ videoPassword ]
+      })
+
+      const videoFileToken = await server.videoToken.getVideoFileToken({ token: null, videoId: uuid, videoPassword })
+
+      await waitJobs([ server ])
+
+      await checkVideoFiles({ id: uuid, expectedStatus: HttpStatusCode.OK_200, token: server.accessToken, videoFileToken, videoPassword })
+    })
+
     it('Should reinject video file token', async function () {
       this.timeout(120000)
 
@@ -294,13 +373,20 @@ describe('Test video static file privacy', function () {
     let permanentLiveId: string
     let permanentLive: LiveVideo
 
+    let passwordProtectedLiveId: string
+    let passwordProtectedLive: LiveVideo
+
+    const correctPassword = 'my super password'
+
     let unrelatedFileToken: string
 
-    async function checkLiveFiles (live: LiveVideo, liveId: string) {
+    async function checkLiveFiles (options: { live: LiveVideo, liveId: string, videoPassword?: string }) {
+      const { live, liveId, videoPassword } = options
       const ffmpegCommand = sendRTMPStream({ rtmpBaseUrl: live.rtmpUrl, streamKey: live.streamKey })
       await server.live.waitUntilPublished({ videoId: liveId })
 
       const video = await server.videos.getWithToken({ id: liveId })
+
       const fileToken = await server.videoToken.getVideoFileToken({ videoId: video.uuid })
 
       const hls = video.streamingPlaylists[0]
@@ -314,6 +400,16 @@ describe('Test video static file privacy', function () {
         await makeRawRequest({ url, token: userToken, expectedStatus: HttpStatusCode.FORBIDDEN_403 })
         await makeRawRequest({ url, expectedStatus: HttpStatusCode.FORBIDDEN_403 })
         await makeRawRequest({ url, query: { videoFileToken: unrelatedFileToken }, expectedStatus: HttpStatusCode.FORBIDDEN_403 })
+
+        if (videoPassword) {
+          await makeRawRequest({ url, headers: { 'x-peertube-video-password': videoPassword }, expectedStatus: HttpStatusCode.OK_200 })
+          await makeRawRequest({
+            url,
+            headers: { 'x-peertube-video-password': 'incorrectPassword' },
+            expectedStatus: HttpStatusCode.FORBIDDEN_403
+          })
+        }
+
       }
 
       await stopFfmpeg(ffmpegCommand)
@@ -381,18 +477,35 @@ describe('Test video static file privacy', function () {
         permanentLiveId = video.uuid
         permanentLive = live
       }
+
+      {
+        const { video, live } = await server.live.quickCreate({
+          saveReplay: false,
+          permanentLive: false,
+          privacy: VideoPrivacy.PASSWORD_PROTECTED,
+          videoPasswords: [ correctPassword ]
+        })
+        passwordProtectedLiveId = video.uuid
+        passwordProtectedLive = live
+      }
     })
 
     it('Should create a private normal live and have a private static path', async function () {
       this.timeout(240000)
 
-      await checkLiveFiles(normalLive, normalLiveId)
+      await checkLiveFiles({ live: normalLive, liveId: normalLiveId })
     })
 
     it('Should create a private permanent live and have a private static path', async function () {
       this.timeout(240000)
 
-      await checkLiveFiles(permanentLive, permanentLiveId)
+      await checkLiveFiles({ live: permanentLive, liveId: permanentLiveId })
+    })
+
+    it('Should create a password protected live and have a private static path', async function () {
+      this.timeout(240000)
+
+      await checkLiveFiles({ live: passwordProtectedLive, liveId: passwordProtectedLiveId, videoPassword: correctPassword })
     })
 
     it('Should reinject video file token on permanent live', async function () {
diff --git a/server/tests/api/videos/video-storyboard.ts b/server/tests/api/videos/video-storyboard.ts
new file mode 100644
index 000000000..fc4b4450f
--- /dev/null
+++ b/server/tests/api/videos/video-storyboard.ts
@@ -0,0 +1,213 @@
+/* eslint-disable @typescript-eslint/no-unused-expressions,@typescript-eslint/require-await */
+
+import { expect } from 'chai'
+import { readdir } from 'fs-extra'
+import { basename } from 'path'
+import { FIXTURE_URLS } from '@server/tests/shared'
+import { areHttpImportTestsDisabled } from '@shared/core-utils'
+import { HttpStatusCode, VideoPrivacy } from '@shared/models'
+import {
+  cleanupTests,
+  createMultipleServers,
+  doubleFollow,
+  makeGetRequest,
+  PeerTubeServer,
+  sendRTMPStream,
+  setAccessTokensToServers,
+  setDefaultVideoChannel,
+  stopFfmpeg,
+  waitJobs
+} from '@shared/server-commands'
+
+async function checkStoryboard (options: {
+  server: PeerTubeServer
+  uuid: string
+  tilesCount?: number
+  minSize?: number
+}) {
+  const { server, uuid, tilesCount, minSize = 1000 } = options
+
+  const { storyboards } = await server.storyboard.list({ id: uuid })
+
+  expect(storyboards).to.have.lengthOf(1)
+
+  const storyboard = storyboards[0]
+
+  expect(storyboard.spriteDuration).to.equal(1)
+  expect(storyboard.spriteHeight).to.equal(108)
+  expect(storyboard.spriteWidth).to.equal(192)
+  expect(storyboard.storyboardPath).to.exist
+
+  if (tilesCount) {
+    expect(storyboard.totalWidth).to.equal(192 * Math.min(tilesCount, 10))
+    expect(storyboard.totalHeight).to.equal(108 * Math.max((tilesCount / 10), 1))
+  }
+
+  const { body } = await makeGetRequest({ url: server.url, path: storyboard.storyboardPath, expectedStatus: HttpStatusCode.OK_200 })
+  expect(body.length).to.be.above(minSize)
+}
+
+describe('Test video storyboard', function () {
+  let servers: PeerTubeServer[]
+
+  let baseUUID: string
+
+  before(async function () {
+    this.timeout(120000)
+
+    servers = await createMultipleServers(2)
+    await setAccessTokensToServers(servers)
+    await setDefaultVideoChannel(servers)
+
+    await doubleFollow(servers[0], servers[1])
+  })
+
+  it('Should generate a storyboard after upload without transcoding', async function () {
+    this.timeout(60000)
+
+    // 5s video
+    const { uuid } = await servers[0].videos.quickUpload({ name: 'upload', fixture: 'video_short.webm' })
+    baseUUID = uuid
+    await waitJobs(servers)
+
+    for (const server of servers) {
+      await checkStoryboard({ server, uuid, tilesCount: 5 })
+    }
+  })
+
+  it('Should generate a storyboard after upload without transcoding with a long video', async function () {
+    this.timeout(60000)
+
+    // 124s video
+    const { uuid } = await servers[0].videos.quickUpload({ name: 'upload', fixture: 'video_very_long_10p.mp4' })
+    await waitJobs(servers)
+
+    for (const server of servers) {
+      await checkStoryboard({ server, uuid, tilesCount: 100 })
+    }
+  })
+
+  it('Should generate a storyboard after upload with transcoding', async function () {
+    this.timeout(60000)
+
+    await servers[0].config.enableMinimumTranscoding()
+
+    // 5s video
+    const { uuid } = await servers[0].videos.quickUpload({ name: 'upload', fixture: 'video_short.webm' })
+    await waitJobs(servers)
+
+    for (const server of servers) {
+      await checkStoryboard({ server, uuid, tilesCount: 5 })
+    }
+  })
+
+  it('Should generate a storyboard after an audio upload', async function () {
+    this.timeout(60000)
+
+    // 6s audio
+    const attributes = { name: 'audio', fixture: 'sample.ogg' }
+    const { uuid } = await servers[0].videos.upload({ attributes, mode: 'legacy' })
+    await waitJobs(servers)
+
+    for (const server of servers) {
+      try {
+        await checkStoryboard({ server, uuid, tilesCount: 6, minSize: 250 })
+      } catch { // FIXME: to remove after ffmpeg CI upgrade, ffmpeg CI version (4.3) generates a 7.6s length video
+        await checkStoryboard({ server, uuid, tilesCount: 8, minSize: 250 })
+      }
+    }
+  })
+
+  it('Should generate a storyboard after HTTP import', async function () {
+    this.timeout(60000)
+
+    if (areHttpImportTestsDisabled()) return
+
+    // 3s video
+    const { video } = await servers[0].imports.importVideo({
+      attributes: {
+        targetUrl: FIXTURE_URLS.goodVideo,
+        channelId: servers[0].store.channel.id,
+        privacy: VideoPrivacy.PUBLIC
+      }
+    })
+    await waitJobs(servers)
+
+    for (const server of servers) {
+      await checkStoryboard({ server, uuid: video.uuid, tilesCount: 3 })
+    }
+  })
+
+  it('Should generate a storyboard after torrent import', async function () {
+    this.timeout(60000)
+
+    if (areHttpImportTestsDisabled()) return
+
+    // 10s video
+    const { video } = await servers[0].imports.importVideo({
+      attributes: {
+        magnetUri: FIXTURE_URLS.magnet,
+        channelId: servers[0].store.channel.id,
+        privacy: VideoPrivacy.PUBLIC
+      }
+    })
+    await waitJobs(servers)
+
+    for (const server of servers) {
+      await checkStoryboard({ server, uuid: video.uuid, tilesCount: 10 })
+    }
+  })
+
+  it('Should generate a storyboard after a live', async function () {
+    this.timeout(240000)
+
+    await servers[0].config.enableLive({ allowReplay: true, transcoding: true, resolutions: 'min' })
+
+    const { live, video } = await servers[0].live.quickCreate({
+      saveReplay: true,
+      permanentLive: false,
+      privacy: VideoPrivacy.PUBLIC
+    })
+
+    const ffmpegCommand = sendRTMPStream({ rtmpBaseUrl: live.rtmpUrl, streamKey: live.streamKey })
+    await servers[0].live.waitUntilPublished({ videoId: video.id })
+
+    await stopFfmpeg(ffmpegCommand)
+
+    await servers[0].live.waitUntilReplacedByReplay({ videoId: video.id })
+    await waitJobs(servers)
+
+    for (const server of servers) {
+      await checkStoryboard({ server, uuid: video.uuid })
+    }
+  })
+
+  it('Should cleanup storyboards on video deletion', async function () {
+    this.timeout(60000)
+
+    const { storyboards } = await servers[0].storyboard.list({ id: baseUUID })
+    const storyboardName = basename(storyboards[0].storyboardPath)
+
+    const listFiles = () => {
+      const storyboardPath = servers[0].getDirectoryPath('storyboards')
+      return readdir(storyboardPath)
+    }
+
+    {
+      const storyboads = await listFiles()
+      expect(storyboads).to.include(storyboardName)
+    }
+
+    await servers[0].videos.remove({ id: baseUUID })
+    await waitJobs(servers)
+
+    {
+      const storyboads = await listFiles()
+      expect(storyboads).to.not.include(storyboardName)
+    }
+  })
+
+  after(async function () {
+    await cleanupTests(servers)
+  })
+})
diff --git a/server/tests/api/videos/videos-common-filters.ts b/server/tests/api/videos/videos-common-filters.ts
index 30251706b..73c066bfb 100644
--- a/server/tests/api/videos/videos-common-filters.ts
+++ b/server/tests/api/videos/videos-common-filters.ts
@@ -154,7 +154,7 @@ describe('Test videos filter', function () {
       server: PeerTubeServer
       path: string
       isLocal?: boolean
-      hasWebtorrentFiles?: boolean
+      hasWebVideoFiles?: boolean
       hasHLSFiles?: boolean
       include?: VideoInclude
       privacyOneOf?: VideoPrivacy[]
@@ -174,7 +174,7 @@ describe('Test videos filter', function () {
             'include',
             'category',
             'tagsAllOf',
-            'hasWebtorrentFiles',
+            'hasWebVideoFiles',
             'hasHLSFiles',
             'privacyOneOf',
             'excludeAlreadyWatched'
@@ -463,14 +463,14 @@ describe('Test videos filter', function () {
       }
     })
 
-    it('Should filter by HLS or WebTorrent files', async function () {
+    it('Should filter by HLS or Web Video files', async function () {
       this.timeout(360000)
 
       const finderFactory = (name: string) => (videos: Video[]) => videos.some(v => v.name === name)
 
       await servers[0].config.enableTranscoding(true, false)
-      await servers[0].videos.upload({ attributes: { name: 'webtorrent video' } })
-      const hasWebtorrent = finderFactory('webtorrent video')
+      await servers[0].videos.upload({ attributes: { name: 'web video video' } })
+      const hasWebVideo = finderFactory('web video video')
 
       await waitJobs(servers)
 
@@ -481,24 +481,24 @@ describe('Test videos filter', function () {
       await waitJobs(servers)
 
       await servers[0].config.enableTranscoding(true, true)
-      await servers[0].videos.upload({ attributes: { name: 'hls and webtorrent video' } })
-      const hasBoth = finderFactory('hls and webtorrent video')
+      await servers[0].videos.upload({ attributes: { name: 'hls and web video video' } })
+      const hasBoth = finderFactory('hls and web video video')
 
       await waitJobs(servers)
 
       for (const path of paths) {
         {
-          const videos = await listVideos({ server: servers[0], path, hasWebtorrentFiles: true })
+          const videos = await listVideos({ server: servers[0], path, hasWebVideoFiles: true })
 
-          expect(hasWebtorrent(videos)).to.be.true
+          expect(hasWebVideo(videos)).to.be.true
           expect(hasHLS(videos)).to.be.false
           expect(hasBoth(videos)).to.be.true
         }
 
         {
-          const videos = await listVideos({ server: servers[0], path, hasWebtorrentFiles: false })
+          const videos = await listVideos({ server: servers[0], path, hasWebVideoFiles: false })
 
-          expect(hasWebtorrent(videos)).to.be.false
+          expect(hasWebVideo(videos)).to.be.false
           expect(hasHLS(videos)).to.be.true
           expect(hasBoth(videos)).to.be.false
         }
@@ -506,7 +506,7 @@ describe('Test videos filter', function () {
         {
           const videos = await listVideos({ server: servers[0], path, hasHLSFiles: true })
 
-          expect(hasWebtorrent(videos)).to.be.false
+          expect(hasWebVideo(videos)).to.be.false
           expect(hasHLS(videos)).to.be.true
           expect(hasBoth(videos)).to.be.true
         }
@@ -514,23 +514,23 @@ describe('Test videos filter', function () {
         {
           const videos = await listVideos({ server: servers[0], path, hasHLSFiles: false })
 
-          expect(hasWebtorrent(videos)).to.be.true
+          expect(hasWebVideo(videos)).to.be.true
           expect(hasHLS(videos)).to.be.false
           expect(hasBoth(videos)).to.be.false
         }
 
         {
-          const videos = await listVideos({ server: servers[0], path, hasHLSFiles: false, hasWebtorrentFiles: false })
+          const videos = await listVideos({ server: servers[0], path, hasHLSFiles: false, hasWebVideoFiles: false })
 
-          expect(hasWebtorrent(videos)).to.be.false
+          expect(hasWebVideo(videos)).to.be.false
           expect(hasHLS(videos)).to.be.false
           expect(hasBoth(videos)).to.be.false
         }
 
         {
-          const videos = await listVideos({ server: servers[0], path, hasHLSFiles: true, hasWebtorrentFiles: true })
+          const videos = await listVideos({ server: servers[0], path, hasHLSFiles: true, hasWebVideoFiles: true })
 
-          expect(hasWebtorrent(videos)).to.be.false
+          expect(hasWebVideo(videos)).to.be.false
           expect(hasHLS(videos)).to.be.false
           expect(hasBoth(videos)).to.be.true
         }
diff --git a/server/tests/cli/create-generate-storyboard-job.ts b/server/tests/cli/create-generate-storyboard-job.ts
new file mode 100644
index 000000000..02a4be8ae
--- /dev/null
+++ b/server/tests/cli/create-generate-storyboard-job.ts
@@ -0,0 +1,120 @@
+/* eslint-disable @typescript-eslint/no-unused-expressions,@typescript-eslint/require-await */
+
+import { expect } from 'chai'
+import { readdir, remove } from 'fs-extra'
+import { join } from 'path'
+import { HttpStatusCode } from '@shared/models'
+import {
+  cleanupTests,
+  createMultipleServers,
+  doubleFollow,
+  makeGetRequest,
+  PeerTubeServer,
+  setAccessTokensToServers,
+  waitJobs
+} from '@shared/server-commands'
+import { SQLCommand } from '../shared'
+
+function listStoryboardFiles (server: PeerTubeServer) {
+  const storage = server.getDirectoryPath('storyboards')
+
+  return readdir(storage)
+}
+
+describe('Test create generate storyboard job', function () {
+  let servers: PeerTubeServer[] = []
+  const uuids: string[] = []
+  let sql: SQLCommand
+  let existingStoryboardName: string
+
+  before(async function () {
+    this.timeout(120000)
+
+    // Run server 2 to have transcoding enabled
+    servers = await createMultipleServers(2)
+    await setAccessTokensToServers(servers)
+
+    await doubleFollow(servers[0], servers[1])
+
+    for (let i = 0; i < 3; i++) {
+      const { uuid } = await servers[0].videos.quickUpload({ name: 'video ' + i })
+      uuids.push(uuid)
+    }
+
+    await waitJobs(servers)
+
+    const storage = servers[0].getDirectoryPath('storyboards')
+    for (const storyboard of await listStoryboardFiles(servers[0])) {
+      await remove(join(storage, storyboard))
+    }
+
+    sql = new SQLCommand(servers[0])
+    await sql.deleteAll('storyboard')
+
+    const { uuid } = await servers[0].videos.quickUpload({ name: 'video 4' })
+    uuids.push(uuid)
+
+    await waitJobs(servers)
+
+    const storyboards = await listStoryboardFiles(servers[0])
+    existingStoryboardName = storyboards[0]
+  })
+
+  it('Should create a storyboard of a video', async function () {
+    this.timeout(120000)
+
+    for (const uuid of [ uuids[0], uuids[3] ]) {
+      const command = `npm run create-generate-storyboard-job -- -v ${uuid}`
+      await servers[0].cli.execWithEnv(command)
+    }
+
+    await waitJobs(servers)
+
+    {
+      const storyboards = await listStoryboardFiles(servers[0])
+      expect(storyboards).to.have.lengthOf(2)
+      expect(storyboards).to.not.include(existingStoryboardName)
+
+      existingStoryboardName = storyboards[0]
+    }
+
+    for (const server of servers) {
+      for (const uuid of [ uuids[0], uuids[3] ]) {
+        const { storyboards } = await server.storyboard.list({ id: uuid })
+        expect(storyboards).to.have.lengthOf(1)
+
+        await makeGetRequest({ url: server.url, path: storyboards[0].storyboardPath, expectedStatus: HttpStatusCode.OK_200 })
+      }
+    }
+  })
+
+  it('Should create missing storyboards', async function () {
+    this.timeout(120000)
+
+    const command = `npm run create-generate-storyboard-job -- -a`
+    await servers[0].cli.execWithEnv(command)
+
+    await waitJobs(servers)
+
+    {
+      const storyboards = await listStoryboardFiles(servers[0])
+      expect(storyboards).to.have.lengthOf(4)
+      expect(storyboards).to.include(existingStoryboardName)
+    }
+
+    for (const server of servers) {
+      for (const uuid of uuids) {
+        const { storyboards } = await server.storyboard.list({ id: uuid })
+        expect(storyboards).to.have.lengthOf(1)
+
+        await makeGetRequest({ url: server.url, path: storyboards[0].storyboardPath, expectedStatus: HttpStatusCode.OK_200 })
+      }
+    }
+  })
+
+  after(async function () {
+    await sql.cleanup()
+
+    await cleanupTests(servers)
+  })
+})
diff --git a/server/tests/cli/create-move-video-storage-job.ts b/server/tests/cli/create-move-video-storage-job.ts
index 253fc983e..fc6a8e648 100644
--- a/server/tests/cli/create-move-video-storage-job.ts
+++ b/server/tests/cli/create-move-video-storage-job.ts
@@ -109,8 +109,8 @@ describe('Test create move video storage job', function () {
   })
 
   it('Should not have files on disk anymore', async function () {
-    await checkDirectoryIsEmpty(servers[0], 'videos', [ 'private' ])
-    await checkDirectoryIsEmpty(servers[0], join('videos', 'private'))
+    await checkDirectoryIsEmpty(servers[0], 'web-videos', [ 'private' ])
+    await checkDirectoryIsEmpty(servers[0], join('web-videos', 'private'))
 
     await checkDirectoryIsEmpty(servers[0], join('streaming-playlists', 'hls'), [ 'private' ])
     await checkDirectoryIsEmpty(servers[0], join('streaming-playlists', 'hls', 'private'))
diff --git a/server/tests/cli/index.ts b/server/tests/cli/index.ts
index 8579be39c..94444ace3 100644
--- a/server/tests/cli/index.ts
+++ b/server/tests/cli/index.ts
@@ -1,5 +1,6 @@
 // Order of the tests we want to execute
 import './create-import-video-file-job'
+import './create-generate-storyboard-job'
 import './create-move-video-storage-job'
 import './peertube'
 import './plugins'
diff --git a/server/tests/cli/prune-storage.ts b/server/tests/cli/prune-storage.ts
index 8bdf2136d..561ed6a68 100644
--- a/server/tests/cli/prune-storage.ts
+++ b/server/tests/cli/prune-storage.ts
@@ -35,10 +35,10 @@ async function assertNotExists (server: PeerTubeServer, directory: string, subst
 
 async function assertCountAreOkay (servers: PeerTubeServer[]) {
   for (const server of servers) {
-    const videosCount = await countFiles(server, 'videos')
+    const videosCount = await countFiles(server, 'web-videos')
     expect(videosCount).to.equal(9) // 2 videos with 4 resolutions + private directory
 
-    const privateVideosCount = await countFiles(server, 'videos/private')
+    const privateVideosCount = await countFiles(server, 'web-videos/private')
     expect(privateVideosCount).to.equal(4)
 
     const torrentsCount = await countFiles(server, 'torrents')
@@ -48,7 +48,7 @@ async function assertCountAreOkay (servers: PeerTubeServer[]) {
     expect(previewsCount).to.equal(3)
 
     const thumbnailsCount = await countFiles(server, 'thumbnails')
-    expect(thumbnailsCount).to.equal(7) // 3 local videos, 1 local playlist, 2 remotes videos and 1 remote playlist
+    expect(thumbnailsCount).to.equal(5) // 3 local videos, 1 local playlist, 2 remotes videos (lazy downloaded) and 1 remote playlist
 
     const avatarsCount = await countFiles(server, 'avatars')
     expect(avatarsCount).to.equal(4)
@@ -85,7 +85,7 @@ describe('Test prune storage scripts', function () {
           displayName: 'playlist',
           privacy: VideoPlaylistPrivacy.PUBLIC,
           videoChannelId: server.store.channel.id,
-          thumbnailfile: 'thumbnail.jpg'
+          thumbnailfile: 'custom-thumbnail.jpg'
         }
       })
     }
@@ -131,8 +131,8 @@ describe('Test prune storage scripts', function () {
   it('Should create some dirty files', async function () {
     for (let i = 0; i < 2; i++) {
       {
-        const basePublic = servers[0].servers.buildDirectory('videos')
-        const basePrivate = servers[0].servers.buildDirectory(join('videos', 'private'))
+        const basePublic = servers[0].servers.buildDirectory('web-videos')
+        const basePrivate = servers[0].servers.buildDirectory(join('web-videos', 'private'))
 
         const n1 = buildUUID() + '.mp4'
         const n2 = buildUUID() + '.webm'
diff --git a/server/tests/cli/regenerate-thumbnails.ts b/server/tests/cli/regenerate-thumbnails.ts
index 16a8adcda..66de7f79c 100644
--- a/server/tests/cli/regenerate-thumbnails.ts
+++ b/server/tests/cli/regenerate-thumbnails.ts
@@ -60,6 +60,9 @@ describe('Test regenerate thumbnails script', function () {
 
       remoteVideo = await servers[0].videos.get({ id: videoUUID })
 
+      // Load remote thumbnail on disk
+      await makeGetRequest({ url: servers[0].url, path: remoteVideo.thumbnailPath, expectedStatus: HttpStatusCode.OK_200 })
+
       thumbnailRemotePath = join(servers[0].servers.buildDirectory('thumbnails'), basename(remoteVideo.thumbnailPath))
     }
 
diff --git a/server/tests/client.ts b/server/tests/client.ts
index e84251561..68f3a1d14 100644
--- a/server/tests/client.ts
+++ b/server/tests/client.ts
@@ -56,6 +56,7 @@ describe('Test a client controllers', function () {
   let privateVideoId: string
   let internalVideoId: string
   let unlistedVideoId: string
+  let passwordProtectedVideoId: string
 
   let playlistIds: (string | number)[] = []
 
@@ -92,7 +93,12 @@ describe('Test a client controllers', function () {
     {
       ({ uuid: privateVideoId } = await servers[0].videos.quickUpload({ name: 'private', privacy: VideoPrivacy.PRIVATE }));
       ({ uuid: unlistedVideoId } = await servers[0].videos.quickUpload({ name: 'unlisted', privacy: VideoPrivacy.UNLISTED }));
-      ({ uuid: internalVideoId } = await servers[0].videos.quickUpload({ name: 'internal', privacy: VideoPrivacy.INTERNAL }))
+      ({ uuid: internalVideoId } = await servers[0].videos.quickUpload({ name: 'internal', privacy: VideoPrivacy.INTERNAL }));
+      ({ uuid: passwordProtectedVideoId } = await servers[0].videos.quickUpload({
+        name: 'password protected',
+        privacy: VideoPrivacy.PASSWORD_PROTECTED,
+        videoPasswords: [ 'password' ]
+      }))
     }
 
     // Playlist
@@ -502,9 +508,9 @@ describe('Test a client controllers', function () {
       }
     })
 
-    it('Should not display internal/private video', async function () {
+    it('Should not display internal/private/password protected video', async function () {
       for (const basePath of watchVideoBasePaths) {
-        for (const id of [ privateVideoId, internalVideoId ]) {
+        for (const id of [ privateVideoId, internalVideoId, passwordProtectedVideoId ]) {
           const res = await makeGetRequest({
             url: servers[0].url,
             path: basePath + id,
@@ -514,6 +520,7 @@ describe('Test a client controllers', function () {
 
           expect(res.text).to.not.contain('internal')
           expect(res.text).to.not.contain('private')
+          expect(res.text).to.not.contain('password protected')
         }
       }
     })
diff --git a/server/tests/feeds/feeds.ts b/server/tests/feeds/feeds.ts
index 8433c873e..1754ac466 100644
--- a/server/tests/feeds/feeds.ts
+++ b/server/tests/feeds/feeds.ts
@@ -47,7 +47,7 @@ describe('Test syndication feeds', () => {
     serverHLSOnly = await createSingleServer(3, {
       transcoding: {
         enabled: true,
-        webtorrent: { enabled: false },
+        web_videos: { enabled: false },
         hls: { enabled: true }
       }
     })
@@ -99,6 +99,13 @@ describe('Test syndication feeds', () => {
       await servers[0].comments.createThread({ videoId: id, text: 'comment on unlisted video' })
     }
 
+    {
+      const attributes = { name: 'password protected video', privacy: VideoPrivacy.PASSWORD_PROTECTED, videoPasswords: [ 'password' ] }
+      const { id } = await servers[0].videos.upload({ attributes })
+
+      await servers[0].comments.createThread({ videoId: id, text: 'comment on password protected video' })
+    }
+
     await serverHLSOnly.videos.upload({ attributes: { name: 'hls only video' } })
 
     await waitJobs([ ...servers, serverHLSOnly ])
@@ -445,7 +452,7 @@ describe('Test syndication feeds', () => {
 
   describe('Video comments feed', function () {
 
-    it('Should contain valid comments (covers JSON feed 1.0 endpoint) and not from unlisted videos', async function () {
+    it('Should contain valid comments (covers JSON feed 1.0 endpoint) and not from unlisted/password protected videos', async function () {
       for (const server of servers) {
         const json = await server.feed.getJSON({ feed: 'video-comments', ignoreCache: true })
 
diff --git a/server/tests/fixtures/custom-preview-big.png b/server/tests/fixtures/custom-preview-big.png
new file mode 100644
index 000000000..03d171af3
--- /dev/null
+++ b/server/tests/fixtures/custom-preview-big.png
diff --git a/server/tests/fixtures/custom-preview.jpg b/server/tests/fixtures/custom-preview.jpg
new file mode 100644
index 000000000..5a039d830
--- /dev/null
+++ b/server/tests/fixtures/custom-preview.jpg
diff --git a/server/tests/fixtures/custom-thumbnail-big.jpg b/server/tests/fixtures/custom-thumbnail-big.jpg
new file mode 100644
index 000000000..08375e425
--- /dev/null
+++ b/server/tests/fixtures/custom-thumbnail-big.jpg
diff --git a/server/tests/fixtures/custom-thumbnail.jpg b/server/tests/fixtures/custom-thumbnail.jpg
new file mode 100644
index 000000000..ef818442d
--- /dev/null
+++ b/server/tests/fixtures/custom-thumbnail.jpg
diff --git a/server/tests/fixtures/custom-thumbnail.png b/server/tests/fixtures/custom-thumbnail.png
new file mode 100644
index 000000000..9f34daec1
--- /dev/null
+++ b/server/tests/fixtures/custom-thumbnail.png
diff --git a/server/tests/fixtures/preview-big.png b/server/tests/fixtures/preview-big.png
deleted file mode 100644
index 612e297f1..000000000
--- a/server/tests/fixtures/preview-big.png
+++ /dev/null
diff --git a/server/tests/fixtures/preview.jpg b/server/tests/fixtures/preview.jpg
deleted file mode 100644
index 1421da738..000000000
--- a/server/tests/fixtures/preview.jpg
+++ /dev/null
diff --git a/server/tests/fixtures/thumbnail-big.jpg b/server/tests/fixtures/thumbnail-big.jpg
deleted file mode 100644
index 537720d24..000000000
--- a/server/tests/fixtures/thumbnail-big.jpg
+++ /dev/null
diff --git a/server/tests/fixtures/thumbnail.jpg b/server/tests/fixtures/thumbnail.jpg
deleted file mode 100644
index 1e2897fb8..000000000
--- a/server/tests/fixtures/thumbnail.jpg
+++ /dev/null
diff --git a/server/tests/fixtures/thumbnail.png b/server/tests/fixtures/thumbnail.png
deleted file mode 100644
index b331aba3b..000000000
--- a/server/tests/fixtures/thumbnail.png
+++ /dev/null
diff --git a/server/tests/fixtures/video_short1-preview.webm.jpg b/server/tests/fixtures/video_short1-preview.webm.jpg
index d65af1f21..15454942d 100644
--- a/server/tests/fixtures/video_short1-preview.webm.jpg
+++ b/server/tests/fixtures/video_short1-preview.webm.jpg
diff --git a/server/tests/fixtures/video_short1.webm.jpg b/server/tests/fixtures/video_short1.webm.jpg
index 0ab7c58ad..b2740d73d 100644
--- a/server/tests/fixtures/video_short1.webm.jpg
+++ b/server/tests/fixtures/video_short1.webm.jpg
diff --git a/server/tests/fixtures/video_short2.webm.jpg b/server/tests/fixtures/video_short2.webm.jpg
index 1e2897fb8..afe476c7f 100644
--- a/server/tests/fixtures/video_short2.webm.jpg
+++ b/server/tests/fixtures/video_short2.webm.jpg
diff --git a/server/tests/fixtures/video_very_long_10p.mp4 b/server/tests/fixtures/video_very_long_10p.mp4
new file mode 100644
index 000000000..852297933
--- /dev/null
+++ b/server/tests/fixtures/video_very_long_10p.mp4
diff --git a/server/tests/helpers/image.ts b/server/tests/helpers/image.ts
index 530c9bacd..6021ffc48 100644
--- a/server/tests/helpers/image.ts
+++ b/server/tests/helpers/image.ts
@@ -35,28 +35,28 @@ describe('Image helpers', function () {
   const thumbnailSize = { width: 280, height: 157 }
 
   it('Should skip processing if the source image is okay', async function () {
-    const input = buildAbsoluteFixturePath('thumbnail.jpg')
+    const input = buildAbsoluteFixturePath('custom-thumbnail.jpg')
     await processImage({ path: input, destination: imageDestJPG, newSize: thumbnailSize, keepOriginal: true })
 
     await checkBuffers(input, imageDestJPG, true)
   })
 
   it('Should not skip processing if the source image does not have the appropriate extension', async function () {
-    const input = buildAbsoluteFixturePath('thumbnail.png')
+    const input = buildAbsoluteFixturePath('custom-thumbnail.png')
     await processImage({ path: input, destination: imageDestJPG, newSize: thumbnailSize, keepOriginal: true })
 
     await checkBuffers(input, imageDestJPG, false)
   })
 
   it('Should not skip processing if the source image does not have the appropriate size', async function () {
-    const input = buildAbsoluteFixturePath('preview.jpg')
+    const input = buildAbsoluteFixturePath('custom-preview.jpg')
     await processImage({ path: input, destination: imageDestJPG, newSize: thumbnailSize, keepOriginal: true })
 
     await checkBuffers(input, imageDestJPG, false)
   })
 
   it('Should not skip processing if the source image does not have the appropriate size', async function () {
-    const input = buildAbsoluteFixturePath('thumbnail-big.jpg')
+    const input = buildAbsoluteFixturePath('custom-thumbnail-big.jpg')
     await processImage({ path: input, destination: imageDestJPG, newSize: thumbnailSize, keepOriginal: true })
 
     await checkBuffers(input, imageDestJPG, false)
diff --git a/server/tests/peertube-runner/studio-transcoding.ts b/server/tests/peertube-runner/studio-transcoding.ts
index 988201947..c265d7934 100644
--- a/server/tests/peertube-runner/studio-transcoding.ts
+++ b/server/tests/peertube-runner/studio-transcoding.ts
@@ -44,8 +44,8 @@ describe('Test studio transcoding in peertube-runner program', function () {
         }
 
         if (objectStorage) {
-          for (const webtorrentFile of video.files) {
-            expectStartWith(webtorrentFile.fileUrl, objectStorage.getMockWebVideosBaseUrl())
+          for (const webVideoFile of video.files) {
+            expectStartWith(webVideoFile.fileUrl, objectStorage.getMockWebVideosBaseUrl())
           }
 
           for (const hlsFile of video.streamingPlaylists[0].files) {
diff --git a/server/tests/peertube-runner/vod-transcoding.ts b/server/tests/peertube-runner/vod-transcoding.ts
index c3f41c097..eef6faf4e 100644
--- a/server/tests/peertube-runner/vod-transcoding.ts
+++ b/server/tests/peertube-runner/vod-transcoding.ts
@@ -24,13 +24,13 @@ describe('Test VOD transcoding in peertube-runner program', function () {
   let peertubeRunner: PeerTubeRunnerProcess
 
   function runSuite (options: {
-    webtorrentEnabled: boolean
+    webVideoEnabled: boolean
     hlsEnabled: boolean
     objectStorage?: ObjectStorageCommand
   }) {
-    const { webtorrentEnabled, hlsEnabled, objectStorage } = options
+    const { webVideoEnabled, hlsEnabled, objectStorage } = options
 
-    const objectStorageBaseUrlWebTorrent = objectStorage
+    const objectStorageBaseUrlWebVideo = objectStorage
       ? objectStorage.getMockWebVideosBaseUrl()
       : undefined
 
@@ -46,13 +46,13 @@ describe('Test VOD transcoding in peertube-runner program', function () {
       await waitJobs(servers, { runnerJobs: true })
 
       for (const server of servers) {
-        if (webtorrentEnabled) {
+        if (webVideoEnabled) {
           await completeWebVideoFilesCheck({
             server,
             originServer: servers[0],
             fixture: 'video_short.mp4',
             videoUUID: uuid,
-            objectStorageBaseUrl: objectStorageBaseUrlWebTorrent,
+            objectStorageBaseUrl: objectStorageBaseUrlWebVideo,
             files: [
               { resolution: 0 },
               { resolution: 144 },
@@ -66,7 +66,7 @@ describe('Test VOD transcoding in peertube-runner program', function () {
 
         if (hlsEnabled) {
           await completeCheckHlsPlaylist({
-            hlsOnly: !webtorrentEnabled,
+            hlsOnly: !webVideoEnabled,
             servers,
             videoUUID: uuid,
             objectStorageBaseUrl: objectStorageBaseUrlHLS,
@@ -84,13 +84,13 @@ describe('Test VOD transcoding in peertube-runner program', function () {
       await waitJobs(servers, { runnerJobs: true })
 
       for (const server of servers) {
-        if (webtorrentEnabled) {
+        if (webVideoEnabled) {
           await completeWebVideoFilesCheck({
             server,
             originServer: servers[0],
             fixture: 'video_short.webm',
             videoUUID: uuid,
-            objectStorageBaseUrl: objectStorageBaseUrlWebTorrent,
+            objectStorageBaseUrl: objectStorageBaseUrlWebVideo,
             files: [
               { resolution: 0 },
               { resolution: 144 },
@@ -104,7 +104,7 @@ describe('Test VOD transcoding in peertube-runner program', function () {
 
         if (hlsEnabled) {
           await completeCheckHlsPlaylist({
-            hlsOnly: !webtorrentEnabled,
+            hlsOnly: !webVideoEnabled,
             servers,
             videoUUID: uuid,
             objectStorageBaseUrl: objectStorageBaseUrlHLS,
@@ -123,13 +123,13 @@ describe('Test VOD transcoding in peertube-runner program', function () {
       await waitJobs(servers, { runnerJobs: true })
 
       for (const server of servers) {
-        if (webtorrentEnabled) {
+        if (webVideoEnabled) {
           await completeWebVideoFilesCheck({
             server,
             originServer: servers[0],
             fixture: 'sample.ogg',
             videoUUID: uuid,
-            objectStorageBaseUrl: objectStorageBaseUrlWebTorrent,
+            objectStorageBaseUrl: objectStorageBaseUrlWebVideo,
             files: [
               { resolution: 0 },
               { resolution: 144 },
@@ -142,7 +142,7 @@ describe('Test VOD transcoding in peertube-runner program', function () {
 
         if (hlsEnabled) {
           await completeCheckHlsPlaylist({
-            hlsOnly: !webtorrentEnabled,
+            hlsOnly: !webVideoEnabled,
             servers,
             videoUUID: uuid,
             objectStorageBaseUrl: objectStorageBaseUrlHLS,
@@ -159,13 +159,13 @@ describe('Test VOD transcoding in peertube-runner program', function () {
 
       await waitJobs(servers, { runnerJobs: true })
 
-      if (webtorrentEnabled) {
+      if (webVideoEnabled) {
         await completeWebVideoFilesCheck({
           server: servers[0],
           originServer: servers[0],
           fixture: 'video_short.mp4',
           videoUUID: uuid,
-          objectStorageBaseUrl: objectStorageBaseUrlWebTorrent,
+          objectStorageBaseUrl: objectStorageBaseUrlWebVideo,
           files: [
             { resolution: 0 },
             { resolution: 144 },
@@ -179,7 +179,7 @@ describe('Test VOD transcoding in peertube-runner program', function () {
 
       if (hlsEnabled) {
         await completeCheckHlsPlaylist({
-          hlsOnly: !webtorrentEnabled,
+          hlsOnly: !webVideoEnabled,
           servers: [ servers[0] ],
           videoUUID: uuid,
           objectStorageBaseUrl: objectStorageBaseUrlHLS,
@@ -203,7 +203,7 @@ describe('Test VOD transcoding in peertube-runner program', function () {
 
       await servers[0].config.enableTranscoding(true, true, true)
 
-      await servers[0].videos.runTranscoding({ transcodingType: 'webtorrent', videoId: uuid })
+      await servers[0].videos.runTranscoding({ transcodingType: 'web-video', videoId: uuid })
       await waitJobs(servers, { runnerJobs: true })
 
       await completeWebVideoFilesCheck({
@@ -211,7 +211,7 @@ describe('Test VOD transcoding in peertube-runner program', function () {
         originServer: servers[0],
         fixture: 'video_short.mp4',
         videoUUID: uuid,
-        objectStorageBaseUrl: objectStorageBaseUrlWebTorrent,
+        objectStorageBaseUrl: objectStorageBaseUrlWebVideo,
         files: [
           { resolution: 0 },
           { resolution: 144 },
@@ -262,7 +262,7 @@ describe('Test VOD transcoding in peertube-runner program', function () {
         await servers[0].config.enableTranscoding(true, false, true)
       })
 
-      runSuite({ webtorrentEnabled: true, hlsEnabled: false })
+      runSuite({ webVideoEnabled: true, hlsEnabled: false })
     })
 
     describe('HLS videos only enabled', function () {
@@ -271,7 +271,7 @@ describe('Test VOD transcoding in peertube-runner program', function () {
         await servers[0].config.enableTranscoding(false, true, true)
       })
 
-      runSuite({ webtorrentEnabled: false, hlsEnabled: true })
+      runSuite({ webVideoEnabled: false, hlsEnabled: true })
     })
 
     describe('Web video & HLS enabled', function () {
@@ -280,7 +280,7 @@ describe('Test VOD transcoding in peertube-runner program', function () {
         await servers[0].config.enableTranscoding(true, true, true)
       })
 
-      runSuite({ webtorrentEnabled: true, hlsEnabled: true })
+      runSuite({ webVideoEnabled: true, hlsEnabled: true })
     })
   })
 
@@ -306,7 +306,7 @@ describe('Test VOD transcoding in peertube-runner program', function () {
         await servers[0].config.enableTranscoding(true, false, true)
       })
 
-      runSuite({ webtorrentEnabled: true, hlsEnabled: false, objectStorage })
+      runSuite({ webVideoEnabled: true, hlsEnabled: false, objectStorage })
     })
 
     describe('HLS videos only enabled', function () {
@@ -315,7 +315,7 @@ describe('Test VOD transcoding in peertube-runner program', function () {
         await servers[0].config.enableTranscoding(false, true, true)
       })
 
-      runSuite({ webtorrentEnabled: false, hlsEnabled: true, objectStorage })
+      runSuite({ webVideoEnabled: false, hlsEnabled: true, objectStorage })
     })
 
     describe('Web video & HLS enabled', function () {
@@ -324,7 +324,7 @@ describe('Test VOD transcoding in peertube-runner program', function () {
         await servers[0].config.enableTranscoding(true, true, true)
       })
 
-      runSuite({ webtorrentEnabled: true, hlsEnabled: true, objectStorage })
+      runSuite({ webVideoEnabled: true, hlsEnabled: true, objectStorage })
     })
 
     after(async function () {
diff --git a/server/tests/plugins/filter-hooks.ts b/server/tests/plugins/filter-hooks.ts
index a02a53c50..a75a8c8fa 100644
--- a/server/tests/plugins/filter-hooks.ts
+++ b/server/tests/plugins/filter-hooks.ts
@@ -493,7 +493,7 @@ describe('Test plugin filter hooks', function () {
       await servers[0].config.updateCustomSubConfig({
         newConfig: {
           transcoding: {
-            webtorrent: {
+            webVideos: {
               enabled: true
             },
             hls: {
diff --git a/server/tests/plugins/plugin-helpers.ts b/server/tests/plugins/plugin-helpers.ts
index e951a1299..f5a0cbe85 100644
--- a/server/tests/plugins/plugin-helpers.ts
+++ b/server/tests/plugins/plugin-helpers.ts
@@ -302,11 +302,11 @@ describe('Test plugin helpers', function () {
 
       // Video files check
       {
-        expect(body.webtorrent.videoFiles).to.be.an('array')
+        expect(body.webVideo.videoFiles).to.be.an('array')
         expect(body.hls.videoFiles).to.be.an('array')
 
         for (const resolution of [ 144, 240, 360, 480, 720 ]) {
-          for (const files of [ body.webtorrent.videoFiles, body.hls.videoFiles ]) {
+          for (const files of [ body.webVideo.videoFiles, body.hls.videoFiles ]) {
             const file = files.find(f => f.resolution === resolution)
             expect(file).to.exist
 
@@ -318,7 +318,7 @@ describe('Test plugin helpers', function () {
           }
         }
 
-        videoPath = body.webtorrent.videoFiles[0].path
+        videoPath = body.webVideo.videoFiles[0].path
       }
 
       // Thumbnails check
diff --git a/server/tests/plugins/plugin-transcoding.ts b/server/tests/plugins/plugin-transcoding.ts
index 689eec5ac..21f82fbac 100644
--- a/server/tests/plugins/plugin-transcoding.ts
+++ b/server/tests/plugins/plugin-transcoding.ts
@@ -35,7 +35,7 @@ function updateConf (server: PeerTubeServer, vodProfile: string, liveProfile: st
         hls: {
           enabled: true
         },
-        webtorrent: {
+        webVideos: {
           enabled: true
         },
         resolutions: {
@@ -247,7 +247,7 @@ describe('Test transcoding plugins', function () {
 
       const video = await server.videos.get({ id: videoUUID })
 
-      const path = server.servers.buildWebTorrentFilePath(video.files[0].fileUrl)
+      const path = server.servers.buildWebVideoFilePath(video.files[0].fileUrl)
       const audioProbe = await getAudioStream(path)
       expect(audioProbe.audioStream.codec_name).to.equal('opus')
 
diff --git a/server/tests/shared/checks.ts b/server/tests/shared/checks.ts
index feaef37c6..90179c6ac 100644
--- a/server/tests/shared/checks.ts
+++ b/server/tests/shared/checks.ts
@@ -61,6 +61,16 @@ async function testImageSize (url: string, imageName: string, imageHTTPPath: str
   expect(body.length).to.be.below(maxLength, 'the generated image is way larger than the recorded fixture')
 }
 
+async function testImageGeneratedByFFmpeg (url: string, imageName: string, imageHTTPPath: string, extension = '.jpg') {
+  if (process.env.ENABLE_FFMPEG_THUMBNAIL_PIXEL_COMPARISON_TESTS !== 'true') {
+    console.log(
+      'Pixel comparison of image generated by ffmpeg is disabled. ' +
+      'You can enable it using `ENABLE_FFMPEG_THUMBNAIL_PIXEL_COMPARISON_TESTS=true env variable')
+  }
+
+  return testImage(url, imageName, imageHTTPPath, extension)
+}
+
 async function testImage (url: string, imageName: string, imageHTTPPath: string, extension = '.jpg') {
   const res = await makeGetRequest({
     url,
@@ -148,6 +158,7 @@ async function checkVideoDuration (server: PeerTubeServer, videoUUID: string, du
 
 export {
   dateIsValid,
+  testImageGeneratedByFFmpeg,
   testImageSize,
   testImage,
   expectLogDoesNotContain,
diff --git a/server/tests/shared/videos.ts b/server/tests/shared/videos.ts
index 856fabd11..e09bd60b5 100644
--- a/server/tests/shared/videos.ts
+++ b/server/tests/shared/videos.ts
@@ -7,7 +7,7 @@ import { loadLanguages, VIDEO_CATEGORIES, VIDEO_LANGUAGES, VIDEO_LICENCES, VIDEO
 import { getLowercaseExtension, pick, uuidRegex } from '@shared/core-utils'
 import { HttpStatusCode, VideoCaption, VideoDetails, VideoPrivacy, VideoResolution } from '@shared/models'
 import { makeRawRequest, PeerTubeServer, VideoEdit, waitJobs } from '@shared/server-commands'
-import { dateIsValid, expectStartWith, testImage } from './checks'
+import { dateIsValid, expectStartWith, testImageGeneratedByFFmpeg } from './checks'
 import { checkWebTorrentWorks } from './webtorrent'
 
 loadLanguages()
@@ -28,7 +28,7 @@ async function completeWebVideoFilesCheck (options: {
   const serverConfig = await originServer.config.getConfig()
   const requiresAuth = video.privacy.id === VideoPrivacy.PRIVATE || video.privacy.id === VideoPrivacy.INTERNAL
 
-  const transcodingEnabled = serverConfig.transcoding.webtorrent.enabled
+  const transcodingEnabled = serverConfig.transcoding.web_videos.enabled
 
   for (const attributeFile of files) {
     const file = video.files.find(f => f.resolution.id === attributeFile.resolution)
@@ -51,11 +51,12 @@ async function completeWebVideoFilesCheck (options: {
       expect(file.torrentUrl).to.match(new RegExp(`${server.url}/lazy-static/torrents/${nameReg}.torrent`))
 
       if (objectStorageBaseUrl && requiresAuth) {
-        expect(file.fileUrl).to.match(new RegExp(`${originServer.url}/object-storage-proxy/webseed/${privatePath}${nameReg}${extension}`))
+        const regexp = new RegExp(`${originServer.url}/object-storage-proxy/web-videos/${privatePath}${nameReg}${extension}`)
+        expect(file.fileUrl).to.match(regexp)
       } else if (objectStorageBaseUrl) {
         expectStartWith(file.fileUrl, objectStorageBaseUrl)
       } else {
-        expect(file.fileUrl).to.match(new RegExp(`${originServer.url}/static/webseed/${privatePath}${nameReg}${extension}`))
+        expect(file.fileUrl).to.match(new RegExp(`${originServer.url}/static/web-videos/${privatePath}${nameReg}${extension}`))
       }
 
       expect(file.fileDownloadUrl).to.match(new RegExp(`${originServer.url}/download/videos/${nameReg}${extension}`))
@@ -197,11 +198,11 @@ async function completeVideoCheck (options: {
   expect(video.downloadEnabled).to.equal(attributes.downloadEnabled)
 
   expect(video.thumbnailPath).to.exist
-  await testImage(server.url, attributes.thumbnailfile || attributes.fixture, video.thumbnailPath)
+  await testImageGeneratedByFFmpeg(server.url, attributes.thumbnailfile || attributes.fixture, video.thumbnailPath)
 
   if (attributes.previewfile) {
     expect(video.previewPath).to.exist
-    await testImage(server.url, attributes.previewfile, video.previewPath)
+    await testImageGeneratedByFFmpeg(server.url, attributes.previewfile, video.previewPath)
   }
 
   await completeWebVideoFilesCheck({ server, originServer, videoUUID: video.uuid, ...pick(attributes, [ 'fixture', 'files' ]) })
@@ -215,22 +216,22 @@ async function checkVideoFilesWereRemoved (options: {
 }) {
   const { video, server, captions = [], onlyVideoFiles = false } = options
 
-  const webtorrentFiles = video.files || []
+  const webVideoFiles = video.files || []
   const hlsFiles = video.streamingPlaylists[0]?.files || []
 
   const thumbnailName = basename(video.thumbnailPath)
   const previewName = basename(video.previewPath)
 
-  const torrentNames = webtorrentFiles.concat(hlsFiles).map(f => basename(f.torrentUrl))
+  const torrentNames = webVideoFiles.concat(hlsFiles).map(f => basename(f.torrentUrl))
 
   const captionNames = captions.map(c => basename(c.captionPath))
 
-  const webtorrentFilenames = webtorrentFiles.map(f => basename(f.fileUrl))
+  const webVideoFilenames = webVideoFiles.map(f => basename(f.fileUrl))
   const hlsFilenames = hlsFiles.map(f => basename(f.fileUrl))
 
   let directories: { [ directory: string ]: string[] } = {
-    videos: webtorrentFilenames,
-    redundancy: webtorrentFilenames,
+    videos: webVideoFilenames,
+    redundancy: webVideoFilenames,
     [join('playlists', 'hls')]: hlsFilenames,
     [join('redundancy', 'hls')]: hlsFilenames
   }
diff --git a/server/tools/peertube-redundancy.ts b/server/tools/peertube-redundancy.ts
index fd6c760b2..c24eb5233 100644
--- a/server/tools/peertube-redundancy.ts
+++ b/server/tools/peertube-redundancy.ts
@@ -65,19 +65,19 @@ async function listRedundanciesCLI (target: VideoRedundanciesTarget) {
   }) as any
 
   for (const redundancy of data) {
-    const webtorrentFiles = redundancy.redundancies.files
+    const webVideoFiles = redundancy.redundancies.files
     const streamingPlaylists = redundancy.redundancies.streamingPlaylists
 
     let totalSize = ''
     if (target === 'remote-videos') {
-      const tmp = webtorrentFiles.concat(streamingPlaylists)
+      const tmp = webVideoFiles.concat(streamingPlaylists)
                                  .reduce((a, b) => a + b.size, 0)
 
       totalSize = bytes(tmp)
     }
 
     const instances = uniqify(
-      webtorrentFiles.concat(streamingPlaylists)
+      webVideoFiles.concat(streamingPlaylists)
                      .map(r => r.fileUrl)
                      .map(u => new URL(u).host)
     )
@@ -86,7 +86,7 @@ async function listRedundanciesCLI (target: VideoRedundanciesTarget) {
       redundancy.id.toString(),
       redundancy.name,
       redundancy.url,
-      webtorrentFiles.length,
+      webVideoFiles.length,
       streamingPlaylists.length,
       instances.join('\n'),
       totalSize
diff --git a/server/types/express.d.ts b/server/types/express.d.ts
index 510b9f94e..9c1be9bd1 100644
--- a/server/types/express.d.ts
+++ b/server/types/express.d.ts
@@ -18,6 +18,7 @@ import {
   MVideoId,
   MVideoImmutable,
   MVideoLiveFormattable,
+  MVideoPassword,
   MVideoPlaylistFull,
   MVideoPlaylistFullSummary
 } from '@server/types/models'
@@ -165,6 +166,8 @@ declare module 'express' {
       videoCommentFull?: MCommentOwnerVideoReply
       videoCommentThread?: MComment
 
+      videoPassword?: MVideoPassword
+
       follow?: MActorFollowActorsDefault
       subscription?: MActorFollowActorsDefaultSubscription
 
diff --git a/server/types/models/video/index.ts b/server/types/models/video/index.ts
index 6e45fcc79..7f05db666 100644
--- a/server/types/models/video/index.ts
+++ b/server/types/models/video/index.ts
@@ -1,6 +1,7 @@
 export * from './local-video-viewer-watch-section'
 export * from './local-video-viewer-watch-section'
 export * from './local-video-viewer'
+export * from './storyboard'
 export * from './schedule-video-update'
 export * from './tag'
 export * from './thumbnail'
@@ -16,6 +17,7 @@ export * from './video-import'
 export * from './video-live-replay-setting'
 export * from './video-live-session'
 export * from './video-live'
+export * from './video-password'
 export * from './video-playlist'
 export * from './video-playlist-element'
 export * from './video-rate'
diff --git a/server/types/models/video/storyboard.ts b/server/types/models/video/storyboard.ts
new file mode 100644
index 000000000..a0403d4f0
--- /dev/null
+++ b/server/types/models/video/storyboard.ts
@@ -0,0 +1,15 @@
+import { StoryboardModel } from '@server/models/video/storyboard'
+import { PickWith } from '@shared/typescript-utils'
+import { MVideo } from './video'
+
+type Use<K extends keyof StoryboardModel, M> = PickWith<StoryboardModel, K, M>
+
+// ############################################################################
+
+export type MStoryboard = Omit<StoryboardModel, 'Video'>
+
+// ############################################################################
+
+export type MStoryboardVideo =
+  MStoryboard &
+  Use<'Video', MVideo>
diff --git a/server/types/models/video/video-caption.ts b/server/types/models/video/video-caption.ts
index 8cd801064..d3adec362 100644
--- a/server/types/models/video/video-caption.ts
+++ b/server/types/models/video/video-caption.ts
@@ -11,7 +11,7 @@ export type MVideoCaption = Omit<VideoCaptionModel, 'Video'>
 // ############################################################################
 
 export type MVideoCaptionLanguage = Pick<MVideoCaption, 'language'>
-export type MVideoCaptionLanguageUrl = Pick<MVideoCaption, 'language' | 'fileUrl' | 'getFileUrl'>
+export type MVideoCaptionLanguageUrl = Pick<MVideoCaption, 'language' | 'fileUrl' | 'filename' | 'getFileUrl' | 'getCaptionStaticPath'>
 
 export type MVideoCaptionVideo =
   MVideoCaption &
diff --git a/server/types/models/video/video-file.ts b/server/types/models/video/video-file.ts
index 55603e59c..68106788d 100644
--- a/server/types/models/video/video-file.ts
+++ b/server/types/models/video/video-file.ts
@@ -38,6 +38,6 @@ export function isStreamingPlaylistFile (file: any): file is MVideoFileStreaming
   return !!file.videoStreamingPlaylistId
 }
 
-export function isWebtorrentFile (file: any): file is MVideoFileVideo {
+export function isWebVideoFile (file: any): file is MVideoFileVideo {
   return !!file.videoId
 }
diff --git a/server/types/models/video/video-password.ts b/server/types/models/video/video-password.ts
new file mode 100644
index 000000000..313cc3e0c
--- /dev/null
+++ b/server/types/models/video/video-password.ts
@@ -0,0 +1,3 @@
+import { VideoPasswordModel } from '@server/models/video/video-password'
+
+export type MVideoPassword = Omit<VideoPasswordModel, 'Video'>
diff --git a/server/types/models/video/video.ts b/server/types/models/video/video.ts
index 58ae7baad..53ee94269 100644
--- a/server/types/models/video/video.ts
+++ b/server/types/models/video/video.ts
@@ -3,6 +3,7 @@ import { VideoModel } from '../../../models/video/video'
 import { MTrackerUrl } from '../server/tracker'
 import { MUserVideoHistoryTime } from '../user/user-video-history'
 import { MScheduleVideoUpdate } from './schedule-video-update'
+import { MStoryboard } from './storyboard'
 import { MTag } from './tag'
 import { MThumbnail } from './thumbnail'
 import { MVideoBlacklist, MVideoBlacklistLight, MVideoBlacklistUnfederated } from './video-blacklist'
@@ -32,7 +33,7 @@ type Use<K extends keyof VideoModel, M> = PickWith<VideoModel, K, M>
 export type MVideo =
   Omit<VideoModel, 'VideoChannel' | 'Tags' | 'Thumbnails' | 'VideoPlaylistElements' | 'VideoAbuses' |
   'VideoFiles' | 'VideoStreamingPlaylists' | 'VideoShares' | 'AccountVideoRates' | 'VideoComments' | 'VideoViews' | 'UserVideoHistories' |
-  'ScheduleVideoUpdate' | 'VideoBlacklist' | 'VideoImport' | 'VideoCaptions' | 'VideoLive' | 'Trackers'>
+  'ScheduleVideoUpdate' | 'VideoBlacklist' | 'VideoImport' | 'VideoCaptions' | 'VideoLive' | 'Trackers' | 'VideoPasswords' | 'Storyboard'>
 
 // ############################################################################
 
@@ -46,7 +47,7 @@ export type MVideoFeed = Pick<MVideo, 'name' | 'uuid'>
 
 // ############################################################################
 
-// Video raw associations: schedules, video files, tags, thumbnails, captions, streaming playlists
+// Video raw associations: schedules, video files, tags, thumbnails, captions, streaming playlists, passwords
 
 // "With" to not confuse with the VideoFile model
 export type MVideoWithFile =
@@ -173,9 +174,10 @@ export type MVideoAP =
   Use<'VideoBlacklist', MVideoBlacklistUnfederated> &
   Use<'VideoFiles', MVideoFileRedundanciesOpt[]> &
   Use<'Thumbnails', MThumbnail[]> &
-  Use<'VideoLive', MVideoLive>
+  Use<'VideoLive', MVideoLive> &
+  Use<'Storyboard', MStoryboard>
 
-export type MVideoAPWithoutCaption = Omit<MVideoAP, 'VideoCaptions'>
+export type MVideoAPLight = Omit<MVideoAP, 'VideoCaptions' | 'Storyboard'>
 
 export type MVideoDetails =
   MVideo &
diff --git a/server/types/plugins/register-server-option.model.ts b/server/types/plugins/register-server-option.model.ts
index df419fff4..103ef234b 100644
--- a/server/types/plugins/register-server-option.model.ts
+++ b/server/types/plugins/register-server-option.model.ts
@@ -41,7 +41,17 @@ export type PeerTubeHelpers = {
     ffprobe: (path: string) => Promise<any>
 
     getFiles: (id: number | string) => Promise<{
-      webtorrent: {
+      webtorrent: { // TODO: remove in v7
+        videoFiles: {
+          path: string // Could be null if using remote storage
+          url: string
+          resolution: number
+          size: number
+          fps: number
+        }[]
+      }
+
+      webVideo: {
         videoFiles: {
           path: string // Could be null if using remote storage
           url: string