341 files changed, 13056 insertions, 4031 deletions

diff --git a/server/controllers/activitypub/client.ts b/server/controllers/activitypub/client.ts
index 1a4e28dc8..d36d10de1 100644
--- a/server/controllers/activitypub/client.ts
+++ b/server/controllers/activitypub/client.ts
@@ -2,28 +2,23 @@
 import * as express from 'express'
 import { VideoPrivacy, VideoRateType } from '../../../shared/models/videos'
 import { activityPubCollectionPagination, activityPubContextify } from '../../helpers/activitypub'
-import { CONFIG, ROUTE_CACHE_LIFETIME } from '../../initializers'
-import { buildAnnounceWithVideoAudience, buildDislikeActivity, buildLikeActivity } from '../../lib/activitypub/send'
+import { ROUTE_CACHE_LIFETIME, WEBSERVER } from '../../initializers/constants'
+import { buildAnnounceWithVideoAudience, buildLikeActivity } from '../../lib/activitypub/send'
 import { audiencify, getAudience } from '../../lib/activitypub/audience'
 import { buildCreateActivity } from '../../lib/activitypub/send/send-create'
 import {
   asyncMiddleware,
-  videosShareValidator,
   executeIfActivityPub,
   localAccountValidator,
   localVideoChannelValidator,
-  videosCustomGetValidator
+  videosCustomGetValidator,
+  videosShareValidator
 } from '../../middlewares'
-import {
-  getAccountVideoRateValidator,
-  videoCommentGetValidator,
-  videosGetValidator
-} from '../../middlewares/validators'
+import { getAccountVideoRateValidator, videoCommentGetValidator } from '../../middlewares/validators'
 import { AccountModel } from '../../models/account/account'
 import { ActorModel } from '../../models/activitypub/actor'
 import { ActorFollowModel } from '../../models/activitypub/actor-follow'
 import { VideoModel } from '../../models/video/video'
-import { VideoChannelModel } from '../../models/video/video-channel'
 import { VideoCommentModel } from '../../models/video/video-comment'
 import { VideoShareModel } from '../../models/video/video-share'
 import { cacheRoute } from '../../middlewares/cache'
@@ -37,87 +32,129 @@ import {
   getVideoSharesActivityPubUrl
 } from '../../lib/activitypub'
 import { VideoCaptionModel } from '../../models/video/video-caption'
-import { videoRedundancyGetValidator } from '../../middlewares/validators/redundancy'
+import { videoFileRedundancyGetValidator, videoPlaylistRedundancyGetValidator } from '../../middlewares/validators/redundancy'
 import { getServerActor } from '../../helpers/utils'
-import { VideoRedundancyModel } from '../../models/redundancy/video-redundancy'
+import { buildDislikeActivity } from '../../lib/activitypub/send/send-dislike'
+import { videoPlaylistElementAPGetValidator, videoPlaylistsGetValidator } from '../../middlewares/validators/videos/video-playlists'
+import { VideoPlaylistModel } from '../../models/video/video-playlist'
+import { VideoPlaylistPrivacy } from '../../../shared/models/videos/playlist/video-playlist-privacy.model'
 
 const activityPubClientRouter = express.Router()
 
 activityPubClientRouter.get('/accounts?/:name',
-  executeIfActivityPub(asyncMiddleware(localAccountValidator)),
-  executeIfActivityPub(accountController)
+  executeIfActivityPub,
+  asyncMiddleware(localAccountValidator),
+  accountController
 )
 activityPubClientRouter.get('/accounts?/:name/followers',
-  executeIfActivityPub(asyncMiddleware(localAccountValidator)),
-  executeIfActivityPub(asyncMiddleware(accountFollowersController))
+  executeIfActivityPub,
+  asyncMiddleware(localAccountValidator),
+  asyncMiddleware(accountFollowersController)
 )
 activityPubClientRouter.get('/accounts?/:name/following',
-  executeIfActivityPub(asyncMiddleware(localAccountValidator)),
-  executeIfActivityPub(asyncMiddleware(accountFollowingController))
+  executeIfActivityPub,
+  asyncMiddleware(localAccountValidator),
+  asyncMiddleware(accountFollowingController)
+)
+activityPubClientRouter.get('/accounts?/:name/playlists',
+  executeIfActivityPub,
+  asyncMiddleware(localAccountValidator),
+  asyncMiddleware(accountPlaylistsController)
 )
 activityPubClientRouter.get('/accounts?/:name/likes/:videoId',
-  executeIfActivityPub(asyncMiddleware(getAccountVideoRateValidator('like'))),
-  executeIfActivityPub(getAccountVideoRate('like'))
+  executeIfActivityPub,
+  asyncMiddleware(getAccountVideoRateValidator('like')),
+  getAccountVideoRate('like')
 )
 activityPubClientRouter.get('/accounts?/:name/dislikes/:videoId',
-  executeIfActivityPub(asyncMiddleware(getAccountVideoRateValidator('dislike'))),
-  executeIfActivityPub(getAccountVideoRate('dislike'))
+  executeIfActivityPub,
+  asyncMiddleware(getAccountVideoRateValidator('dislike')),
+  getAccountVideoRate('dislike')
 )
 
 activityPubClientRouter.get('/videos/watch/:id',
-  executeIfActivityPub(asyncMiddleware(cacheRoute(ROUTE_CACHE_LIFETIME.ACTIVITY_PUB.VIDEOS))),
-  executeIfActivityPub(asyncMiddleware(videosGetValidator)),
-  executeIfActivityPub(asyncMiddleware(videoController))
+  executeIfActivityPub,
+  asyncMiddleware(cacheRoute(ROUTE_CACHE_LIFETIME.ACTIVITY_PUB.VIDEOS)),
+  asyncMiddleware(videosCustomGetValidator('only-video-with-rights')),
+  asyncMiddleware(videoController)
 )
 activityPubClientRouter.get('/videos/watch/:id/activity',
-  executeIfActivityPub(asyncMiddleware(videosGetValidator)),
-  executeIfActivityPub(asyncMiddleware(videoController))
+  executeIfActivityPub,
+  asyncMiddleware(videosCustomGetValidator('only-video-with-rights')),
+  asyncMiddleware(videoController)
 )
 activityPubClientRouter.get('/videos/watch/:id/announces',
-  executeIfActivityPub(asyncMiddleware(videosCustomGetValidator('only-video'))),
-  executeIfActivityPub(asyncMiddleware(videoAnnouncesController))
+  executeIfActivityPub,
+  asyncMiddleware(videosCustomGetValidator('only-video')),
+  asyncMiddleware(videoAnnouncesController)
 )
 activityPubClientRouter.get('/videos/watch/:id/announces/:actorId',
-  executeIfActivityPub(asyncMiddleware(videosShareValidator)),
-  executeIfActivityPub(asyncMiddleware(videoAnnounceController))
+  executeIfActivityPub,
+  asyncMiddleware(videosShareValidator),
+  asyncMiddleware(videoAnnounceController)
 )
 activityPubClientRouter.get('/videos/watch/:id/likes',
-  executeIfActivityPub(asyncMiddleware(videosCustomGetValidator('only-video'))),
-  executeIfActivityPub(asyncMiddleware(videoLikesController))
+  executeIfActivityPub,
+  asyncMiddleware(videosCustomGetValidator('only-video')),
+  asyncMiddleware(videoLikesController)
 )
 activityPubClientRouter.get('/videos/watch/:id/dislikes',
-  executeIfActivityPub(asyncMiddleware(videosCustomGetValidator('only-video'))),
-  executeIfActivityPub(asyncMiddleware(videoDislikesController))
+  executeIfActivityPub,
+  asyncMiddleware(videosCustomGetValidator('only-video')),
+  asyncMiddleware(videoDislikesController)
 )
 activityPubClientRouter.get('/videos/watch/:id/comments',
-  executeIfActivityPub(asyncMiddleware(videosCustomGetValidator('only-video'))),
-  executeIfActivityPub(asyncMiddleware(videoCommentsController))
+  executeIfActivityPub,
+  asyncMiddleware(videosCustomGetValidator('only-video')),
+  asyncMiddleware(videoCommentsController)
 )
 activityPubClientRouter.get('/videos/watch/:videoId/comments/:commentId',
-  executeIfActivityPub(asyncMiddleware(videoCommentGetValidator)),
-  executeIfActivityPub(asyncMiddleware(videoCommentController))
+  executeIfActivityPub,
+  asyncMiddleware(videoCommentGetValidator),
+  asyncMiddleware(videoCommentController)
 )
 activityPubClientRouter.get('/videos/watch/:videoId/comments/:commentId/activity',
-  executeIfActivityPub(asyncMiddleware(videoCommentGetValidator)),
-  executeIfActivityPub(asyncMiddleware(videoCommentController))
+  executeIfActivityPub,
+  asyncMiddleware(videoCommentGetValidator),
+  asyncMiddleware(videoCommentController)
 )
 
 activityPubClientRouter.get('/video-channels/:name',
-  executeIfActivityPub(asyncMiddleware(localVideoChannelValidator)),
-  executeIfActivityPub(asyncMiddleware(videoChannelController))
+  executeIfActivityPub,
+  asyncMiddleware(localVideoChannelValidator),
+  asyncMiddleware(videoChannelController)
 )
 activityPubClientRouter.get('/video-channels/:name/followers',
-  executeIfActivityPub(asyncMiddleware(localVideoChannelValidator)),
-  executeIfActivityPub(asyncMiddleware(videoChannelFollowersController))
+  executeIfActivityPub,
+  asyncMiddleware(localVideoChannelValidator),
+  asyncMiddleware(videoChannelFollowersController)
 )
 activityPubClientRouter.get('/video-channels/:name/following',
-  executeIfActivityPub(asyncMiddleware(localVideoChannelValidator)),
-  executeIfActivityPub(asyncMiddleware(videoChannelFollowingController))
+  executeIfActivityPub,
+  asyncMiddleware(localVideoChannelValidator),
+  asyncMiddleware(videoChannelFollowingController)
 )
 
 activityPubClientRouter.get('/redundancy/videos/:videoId/:resolution([0-9]+)(-:fps([0-9]+))?',
-  executeIfActivityPub(asyncMiddleware(videoRedundancyGetValidator)),
-  executeIfActivityPub(asyncMiddleware(videoRedundancyController))
+  executeIfActivityPub,
+  asyncMiddleware(videoFileRedundancyGetValidator),
+  asyncMiddleware(videoRedundancyController)
+)
+activityPubClientRouter.get('/redundancy/streaming-playlists/:streamingPlaylistType/:videoId',
+  executeIfActivityPub,
+  asyncMiddleware(videoPlaylistRedundancyGetValidator),
+  asyncMiddleware(videoRedundancyController)
+)
+
+activityPubClientRouter.get('/video-playlists/:playlistId',
+  executeIfActivityPub,
+  asyncMiddleware(videoPlaylistsGetValidator),
+  asyncMiddleware(videoPlaylistController)
+)
+activityPubClientRouter.get('/video-playlists/:playlistId/:videoId',
+  executeIfActivityPub,
+  asyncMiddleware(videoPlaylistElementAPGetValidator),
+  asyncMiddleware(videoPlaylistElementController)
 )
 
 // ---------------------------------------------------------------------------
@@ -128,44 +165,52 @@ export {
 
 // ---------------------------------------------------------------------------
 
-function accountController (req: express.Request, res: express.Response, next: express.NextFunction) {
-  const account: AccountModel = res.locals.account
+function accountController (req: express.Request, res: express.Response) {
+  const account = res.locals.account
 
   return activityPubResponse(activityPubContextify(account.toActivityPubObject()), res)
 }
 
-async function accountFollowersController (req: express.Request, res: express.Response, next: express.NextFunction) {
-  const account: AccountModel = res.locals.account
+async function accountFollowersController (req: express.Request, res: express.Response) {
+  const account = res.locals.account
   const activityPubResult = await actorFollowers(req, account.Actor)
 
   return activityPubResponse(activityPubContextify(activityPubResult), res)
 }
 
-async function accountFollowingController (req: express.Request, res: express.Response, next: express.NextFunction) {
-  const account: AccountModel = res.locals.account
+async function accountFollowingController (req: express.Request, res: express.Response) {
+  const account = res.locals.account
   const activityPubResult = await actorFollowing(req, account.Actor)
 
   return activityPubResponse(activityPubContextify(activityPubResult), res)
 }
 
+async function accountPlaylistsController (req: express.Request, res: express.Response) {
+  const account = res.locals.account
+  const activityPubResult = await actorPlaylists(req, account)
+
+  return activityPubResponse(activityPubContextify(activityPubResult), res)
+}
+
 function getAccountVideoRate (rateType: VideoRateType) {
   return (req: express.Request, res: express.Response) => {
-    const accountVideoRate: AccountVideoRateModel = res.locals.accountVideoRate
+    const accountVideoRate = res.locals.accountVideoRate
 
     const byActor = accountVideoRate.Account.Actor
     const url = getRateUrl(rateType, byActor, accountVideoRate.Video)
     const APObject = rateType === 'like'
       ? buildLikeActivity(url, byActor, accountVideoRate.Video)
-      : buildCreateActivity(url, byActor, buildDislikeActivity(url, byActor, accountVideoRate.Video))
+      : buildDislikeActivity(url, byActor, accountVideoRate.Video)
 
     return activityPubResponse(activityPubContextify(APObject), res)
   }
 }
 
 async function videoController (req: express.Request, res: express.Response) {
-  const video: VideoModel = res.locals.video
+  // We need more attributes
+  const video = await VideoModel.loadForGetAPI(res.locals.video.id)
 
-  if (video.url.startsWith(CONFIG.WEBSERVER.URL) === false) return res.redirect(video.url)
+  if (video.url.startsWith(WEBSERVER.URL) === false) return res.redirect(video.url)
 
   // We need captions to render AP object
   video.VideoCaptions = await VideoCaptionModel.listVideoCaptions(video.id)
@@ -182,9 +227,9 @@ async function videoController (req: express.Request, res: express.Response) {
 }
 
 async function videoAnnounceController (req: express.Request, res: express.Response) {
-  const share = res.locals.videoShare as VideoShareModel
+  const share = res.locals.videoShare
 
-  if (share.url.startsWith(CONFIG.WEBSERVER.URL) === false) return res.redirect(share.url)
+  if (share.url.startsWith(WEBSERVER.URL) === false) return res.redirect(share.url)
 
   const { activity } = await buildAnnounceWithVideoAudience(share.Actor, share, res.locals.video, undefined)
 
@@ -192,7 +237,7 @@ async function videoAnnounceController (req: express.Request, res: express.Respo
 }
 
 async function videoAnnouncesController (req: express.Request, res: express.Response) {
-  const video: VideoModel = res.locals.video
+  const video = res.locals.video
 
   const handler = async (start: number, count: number) => {
     const result = await VideoShareModel.listAndCountByVideoId(video.id, start, count)
@@ -207,21 +252,21 @@ async function videoAnnouncesController (req: express.Request, res: express.Resp
 }
 
 async function videoLikesController (req: express.Request, res: express.Response) {
-  const video: VideoModel = res.locals.video
+  const video = res.locals.video
   const json = await videoRates(req, 'like', video, getVideoLikesActivityPubUrl(video))
 
   return activityPubResponse(activityPubContextify(json), res)
 }
 
 async function videoDislikesController (req: express.Request, res: express.Response) {
-  const video: VideoModel = res.locals.video
+  const video = res.locals.video
   const json = await videoRates(req, 'dislike', video, getVideoDislikesActivityPubUrl(video))
 
   return activityPubResponse(activityPubContextify(json), res)
 }
 
 async function videoCommentsController (req: express.Request, res: express.Response) {
-  const video: VideoModel = res.locals.video
+  const video = res.locals.video
 
   const handler = async (start: number, count: number) => {
     const result = await VideoCommentModel.listAndCountByVideoId(video.id, start, count)
@@ -236,29 +281,29 @@ async function videoCommentsController (req: express.Request, res: express.Respo
 }
 
 async function videoChannelController (req: express.Request, res: express.Response) {
-  const videoChannel: VideoChannelModel = res.locals.videoChannel
+  const videoChannel = res.locals.videoChannel
 
   return activityPubResponse(activityPubContextify(videoChannel.toActivityPubObject()), res)
 }
 
 async function videoChannelFollowersController (req: express.Request, res: express.Response) {
-  const videoChannel: VideoChannelModel = res.locals.videoChannel
+  const videoChannel = res.locals.videoChannel
   const activityPubResult = await actorFollowers(req, videoChannel.Actor)
 
   return activityPubResponse(activityPubContextify(activityPubResult), res)
 }
 
 async function videoChannelFollowingController (req: express.Request, res: express.Response) {
-  const videoChannel: VideoChannelModel = res.locals.videoChannel
+  const videoChannel = res.locals.videoChannel
   const activityPubResult = await actorFollowing(req, videoChannel.Actor)
 
   return activityPubResponse(activityPubContextify(activityPubResult), res)
 }
 
 async function videoCommentController (req: express.Request, res: express.Response) {
-  const videoComment: VideoCommentModel = res.locals.videoComment
+  const videoComment = res.locals.videoComment
 
-  if (videoComment.url.startsWith(CONFIG.WEBSERVER.URL) === false) return res.redirect(videoComment.url)
+  if (videoComment.url.startsWith(WEBSERVER.URL) === false) return res.redirect(videoComment.url)
 
   const threadParentComments = await VideoCommentModel.listThreadParentComments(videoComment, undefined)
   const isPublic = true // Comments are always public
@@ -275,8 +320,8 @@ async function videoCommentController (req: express.Request, res: express.Respon
 }
 
 async function videoRedundancyController (req: express.Request, res: express.Response) {
-  const videoRedundancy: VideoRedundancyModel = res.locals.videoRedundancy
-  if (videoRedundancy.url.startsWith(CONFIG.WEBSERVER.URL) === false) return res.redirect(videoRedundancy.url)
+  const videoRedundancy = res.locals.videoRedundancy
+  if (videoRedundancy.url.startsWith(WEBSERVER.URL) === false) return res.redirect(videoRedundancy.url)
 
   const serverActor = await getServerActor()
 
@@ -291,6 +336,26 @@ async function videoRedundancyController (req: express.Request, res: express.Res
   return activityPubResponse(activityPubContextify(object), res)
 }
 
+async function videoPlaylistController (req: express.Request, res: express.Response) {
+  const playlist = res.locals.videoPlaylist
+
+  // We need more attributes
+  playlist.OwnerAccount = await AccountModel.load(playlist.ownerAccountId)
+
+  const json = await playlist.toActivityPubObject(req.query.page, null)
+  const audience = getAudience(playlist.OwnerAccount.Actor, playlist.privacy === VideoPlaylistPrivacy.PUBLIC)
+  const object = audiencify(json, audience)
+
+  return activityPubResponse(activityPubContextify(object), res)
+}
+
+async function videoPlaylistElementController (req: express.Request, res: express.Response) {
+  const videoPlaylistElement = res.locals.videoPlaylistElement
+
+  const json = videoPlaylistElement.toActivityPubObject()
+  return activityPubResponse(activityPubContextify(json), res)
+}
+
 // ---------------------------------------------------------------------------
 
 async function actorFollowing (req: express.Request, actor: ActorModel) {
@@ -298,15 +363,23 @@ async function actorFollowing (req: express.Request, actor: ActorModel) {
     return ActorFollowModel.listAcceptedFollowingUrlsForApi([ actor.id ], undefined, start, count)
   }
 
-  return activityPubCollectionPagination(CONFIG.WEBSERVER.URL + req.path, handler, req.query.page)
+  return activityPubCollectionPagination(WEBSERVER.URL + req.path, handler, req.query.page)
 }
 
 async function actorFollowers (req: express.Request, actor: ActorModel) {
   const handler = (start: number, count: number) => {
-    return ActorFollowModel.listAcceptedFollowerUrlsForApi([ actor.id ], undefined, start, count)
+    return ActorFollowModel.listAcceptedFollowerUrlsForAP([ actor.id ], undefined, start, count)
+  }
+
+  return activityPubCollectionPagination(WEBSERVER.URL + req.path, handler, req.query.page)
+}
+
+async function actorPlaylists (req: express.Request, account: AccountModel) {
+  const handler = (start: number, count: number) => {
+    return VideoPlaylistModel.listPublicUrlsOfForAP(account.id, start, count)
   }
 
-  return activityPubCollectionPagination(CONFIG.WEBSERVER.URL + req.path, handler, req.query.page)
+  return activityPubCollectionPagination(WEBSERVER.URL + req.path, handler, req.query.page)
 }
 
 function videoRates (req: express.Request, rateType: VideoRateType, video: VideoModel, url: string) {
diff --git a/server/controllers/activitypub/inbox.ts b/server/controllers/activitypub/inbox.ts
index f0e65015b..38d5c51df 100644
--- a/server/controllers/activitypub/inbox.ts
+++ b/server/controllers/activitypub/inbox.ts
@@ -5,8 +5,6 @@ import { logger } from '../../helpers/logger'
 import { processActivities } from '../../lib/activitypub/process/process'
 import { asyncMiddleware, checkSignature, localAccountValidator, localVideoChannelValidator, signatureValidator } from '../../middlewares'
 import { activityPubValidator } from '../../middlewares/validators/activitypub/activity'
-import { VideoChannelModel } from '../../models/video/video-channel'
-import { AccountModel } from '../../models/account/account'
 import { queue } from 'async'
 import { ActorModel } from '../../models/activitypub/actor'
 
@@ -66,12 +64,7 @@ function inboxController (req: express.Request, res: express.Response) {
   activities = activities.filter(a => isActivityValid(a))
   logger.debug('We keep %d activities.', activities.length, { activities })
 
-  let accountOrChannel: VideoChannelModel | AccountModel
-  if (res.locals.account) {
-    accountOrChannel = res.locals.account
-  } else if (res.locals.videoChannel) {
-    accountOrChannel = res.locals.videoChannel
-  }
+  const accountOrChannel = res.locals.account || res.locals.videoChannel
 
   logger.info('Receiving inbox requests for %d activities by %s.', activities.length, res.locals.signature.actor.url)
 
diff --git a/server/controllers/activitypub/outbox.ts b/server/controllers/activitypub/outbox.ts
index bd0e4fe9d..38b6ec976 100644
--- a/server/controllers/activitypub/outbox.ts
+++ b/server/controllers/activitypub/outbox.ts
@@ -32,8 +32,8 @@ export {
 
 // ---------------------------------------------------------------------------
 
-async function outboxController (req: express.Request, res: express.Response, next: express.NextFunction) {
-  const accountOrVideoChannel: AccountModel | VideoChannelModel = res.locals.account || res.locals.videoChannel
+async function outboxController (req: express.Request, res: express.Response) {
+  const accountOrVideoChannel = res.locals.account || res.locals.videoChannel
   const actor = accountOrVideoChannel.Actor
   const actorOutboxUrl = actor.url + '/outbox'
 
diff --git a/server/controllers/api/accounts.ts b/server/controllers/api/accounts.ts
index 8c0237203..8d4db1e75 100644
--- a/server/controllers/api/accounts.ts
+++ b/server/controllers/api/accounts.ts
@@ -1,21 +1,32 @@
 import * as express from 'express'
-import { getFormattedObjects } from '../../helpers/utils'
+import { getFormattedObjects, getServerActor } from '../../helpers/utils'
 import {
   asyncMiddleware,
+  authenticate,
   commonVideosFiltersValidator,
-  listVideoAccountChannelsValidator,
   optionalAuthenticate,
   paginationValidator,
   setDefaultPagination,
-  setDefaultSort
+  setDefaultSort,
+  videoPlaylistsSortValidator,
+  videoRatesSortValidator,
+  videoRatingValidator
 } from '../../middlewares'
-import { accountsNameWithHostGetValidator, accountsSortValidator, videosSortValidator } from '../../middlewares/validators'
+import {
+  accountNameWithHostGetValidator,
+  accountsSortValidator,
+  ensureAuthUserOwnsAccountValidator,
+  videosSortValidator
+} from '../../middlewares/validators'
 import { AccountModel } from '../../models/account/account'
+import { AccountVideoRateModel } from '../../models/account/account-video-rate'
 import { VideoModel } from '../../models/video/video'
 import { buildNSFWFilter, isUserAbleToSearchRemoteURI } from '../../helpers/express-utils'
 import { VideoChannelModel } from '../../models/video/video-channel'
 import { JobQueue } from '../../lib/job-queue'
 import { logger } from '../../helpers/logger'
+import { VideoPlaylistModel } from '../../models/video/video-playlist'
+import { commonVideoPlaylistFiltersValidator } from '../../middlewares/validators/videos/video-playlists'
 
 const accountsRouter = express.Router()
 
@@ -28,12 +39,12 @@ accountsRouter.get('/',
 )
 
 accountsRouter.get('/:accountName',
-  asyncMiddleware(accountsNameWithHostGetValidator),
+  asyncMiddleware(accountNameWithHostGetValidator),
   getAccount
 )
 
 accountsRouter.get('/:accountName/videos',
-  asyncMiddleware(accountsNameWithHostGetValidator),
+  asyncMiddleware(accountNameWithHostGetValidator),
   paginationValidator,
   videosSortValidator,
   setDefaultSort,
@@ -44,8 +55,31 @@ accountsRouter.get('/:accountName/videos',
 )
 
 accountsRouter.get('/:accountName/video-channels',
-  asyncMiddleware(listVideoAccountChannelsValidator),
-  asyncMiddleware(listVideoAccountChannels)
+  asyncMiddleware(accountNameWithHostGetValidator),
+  asyncMiddleware(listAccountChannels)
+)
+
+accountsRouter.get('/:accountName/video-playlists',
+  optionalAuthenticate,
+  asyncMiddleware(accountNameWithHostGetValidator),
+  paginationValidator,
+  videoPlaylistsSortValidator,
+  setDefaultSort,
+  setDefaultPagination,
+  commonVideoPlaylistFiltersValidator,
+  asyncMiddleware(listAccountPlaylists)
+)
+
+accountsRouter.get('/:accountName/ratings',
+  authenticate,
+  asyncMiddleware(accountNameWithHostGetValidator),
+  ensureAuthUserOwnsAccountValidator,
+  paginationValidator,
+  videoRatesSortValidator,
+  setDefaultSort,
+  setDefaultPagination,
+  videoRatingValidator,
+  asyncMiddleware(listAccountRatings)
 )
 
 // ---------------------------------------------------------------------------
@@ -56,8 +90,8 @@ export {
 
 // ---------------------------------------------------------------------------
 
-function getAccount (req: express.Request, res: express.Response, next: express.NextFunction) {
-  const account: AccountModel = res.locals.account
+function getAccount (req: express.Request, res: express.Response) {
+  const account = res.locals.account
 
   if (account.isOutdated()) {
     JobQueue.Instance.createJob({ type: 'activitypub-refresher', payload: { type: 'actor', url: account.Actor.url } })
@@ -67,20 +101,42 @@ function getAccount (req: express.Request, res: express.Response, next: express.
   return res.json(account.toFormattedJSON())
 }
 
-async function listAccounts (req: express.Request, res: express.Response, next: express.NextFunction) {
+async function listAccounts (req: express.Request, res: express.Response) {
   const resultList = await AccountModel.listForApi(req.query.start, req.query.count, req.query.sort)
 
   return res.json(getFormattedObjects(resultList.data, resultList.total))
 }
 
-async function listVideoAccountChannels (req: express.Request, res: express.Response, next: express.NextFunction) {
+async function listAccountChannels (req: express.Request, res: express.Response) {
   const resultList = await VideoChannelModel.listByAccount(res.locals.account.id)
 
   return res.json(getFormattedObjects(resultList.data, resultList.total))
 }
 
-async function listAccountVideos (req: express.Request, res: express.Response, next: express.NextFunction) {
-  const account: AccountModel = res.locals.account
+async function listAccountPlaylists (req: express.Request, res: express.Response) {
+  const serverActor = await getServerActor()
+
+  // Allow users to see their private/unlisted video playlists
+  let privateAndUnlisted = false
+  if (res.locals.oauth && res.locals.oauth.token.User.Account.id === res.locals.account.id) {
+    privateAndUnlisted = true
+  }
+
+  const resultList = await VideoPlaylistModel.listForApi({
+    followerActorId: serverActor.id,
+    start: req.query.start,
+    count: req.query.count,
+    sort: req.query.sort,
+    accountId: res.locals.account.id,
+    privateAndUnlisted,
+    type: req.query.playlistType
+  })
+
+  return res.json(getFormattedObjects(resultList.data, resultList.total))
+}
+
+async function listAccountVideos (req: express.Request, res: express.Response) {
+  const account = res.locals.account
   const followerActorId = isUserAbleToSearchRemoteURI(res) ? null : undefined
 
   const resultList = await VideoModel.listForApi({
@@ -103,3 +159,16 @@ async function listAccountVideos (req: express.Request, res: express.Response, n
 
   return res.json(getFormattedObjects(resultList.data, resultList.total))
 }
+
+async function listAccountRatings (req: express.Request, res: express.Response) {
+  const account = res.locals.account
+
+  const resultList = await AccountVideoRateModel.listByAccountForApi({
+    accountId: account.id,
+    start: req.query.start,
+    count: req.query.count,
+    sort: req.query.sort,
+    type: req.query.rating
+  })
+  return res.json(getFormattedObjects(resultList.rows, resultList.count))
+}
diff --git a/server/controllers/api/config.ts b/server/controllers/api/config.ts
index 255026f46..40012c03b 100644
--- a/server/controllers/api/config.ts
+++ b/server/controllers/api/config.ts
@@ -1,10 +1,10 @@
 import * as express from 'express'
-import { omit, snakeCase } from 'lodash'
+import { snakeCase } from 'lodash'
 import { ServerConfig, UserRight } from '../../../shared'
 import { About } from '../../../shared/models/server/about.model'
 import { CustomConfig } from '../../../shared/models/server/custom-config.model'
 import { isSignupAllowed, isSignupAllowedForCurrentIP } from '../../helpers/signup'
-import { CONFIG, CONSTRAINTS_FIELDS, reloadConfig } from '../../initializers'
+import { CONSTRAINTS_FIELDS } from '../../initializers/constants'
 import { asyncMiddleware, authenticate, ensureUserHasRight } from '../../middlewares'
 import { customConfigUpdateValidator } from '../../middlewares/validators/config'
 import { ClientHtml } from '../../lib/client-html'
@@ -14,6 +14,7 @@ import { getServerCommit } from '../../helpers/utils'
 import { Emailer } from '../../lib/emailer'
 import { isNumeric } from 'validator'
 import { objectConverter } from '../../helpers/core-utils'
+import { CONFIG, reloadConfig } from '../../initializers/config'
 
 const packageJSON = require('../../../../package.json')
 const configRouter = express.Router()
@@ -58,6 +59,7 @@ async function getConfig (req: express.Request, res: express.Response) {
       name: CONFIG.INSTANCE.NAME,
       shortDescription: CONFIG.INSTANCE.SHORT_DESCRIPTION,
       defaultClientRoute: CONFIG.INSTANCE.DEFAULT_CLIENT_ROUTE,
+      isNSFW: CONFIG.INSTANCE.IS_NSFW,
       defaultNSFWPolicy: CONFIG.INSTANCE.DEFAULT_NSFW_POLICY,
       customizations: {
         javascript: CONFIG.INSTANCE.CUSTOMIZATIONS.JAVASCRIPT,
@@ -78,6 +80,9 @@ async function getConfig (req: express.Request, res: express.Response) {
       requiresEmailVerification: CONFIG.SIGNUP.REQUIRES_EMAIL_VERIFICATION
     },
     transcoding: {
+      hls: {
+        enabled: CONFIG.TRANSCODING.HLS.ENABLED
+      },
       enabledResolutions
     },
     import: {
@@ -90,6 +95,13 @@ async function getConfig (req: express.Request, res: express.Response) {
         }
       }
     },
+    autoBlacklist: {
+      videos: {
+        ofUsers: {
+          enabled: CONFIG.AUTO_BLACKLIST.VIDEOS.OF_USERS.ENABLED
+        }
+      }
+    },
     avatar: {
       file: {
         size: {
@@ -125,13 +137,16 @@ async function getConfig (req: express.Request, res: express.Response) {
       videos: {
         intervalDays: CONFIG.TRENDING.VIDEOS.INTERVAL_DAYS
       }
+    },
+    tracker: {
+      enabled: CONFIG.TRACKER.ENABLED
     }
   }
 
   return res.json(json)
 }
 
-function getAbout (req: express.Request, res: express.Response, next: express.NextFunction) {
+function getAbout (req: express.Request, res: express.Response) {
   const about: About = {
     instance: {
       name: CONFIG.INSTANCE.NAME,
@@ -144,13 +159,13 @@ function getAbout (req: express.Request, res: express.Response, next: express.Ne
   return res.json(about).end()
 }
 
-async function getCustomConfig (req: express.Request, res: express.Response, next: express.NextFunction) {
+async function getCustomConfig (req: express.Request, res: express.Response) {
   const data = customConfig()
 
   return res.json(data).end()
 }
 
-async function deleteCustomConfig (req: express.Request, res: express.Response, next: express.NextFunction) {
+async function deleteCustomConfig (req: express.Request, res: express.Response) {
   await remove(CONFIG.CUSTOM_FILE)
 
   auditLogger.delete(getAuditIdFromRes(res), new CustomConfigAuditView(customConfig()))
@@ -163,7 +178,7 @@ async function deleteCustomConfig (req: express.Request, res: express.Response,
   return res.json(data).end()
 }
 
-async function updateCustomConfig (req: express.Request, res: express.Response, next: express.NextFunction) {
+async function updateCustomConfig (req: express.Request, res: express.Response) {
   const oldCustomConfigAuditKeys = new CustomConfigAuditView(customConfig())
 
   // camelCase to snake_case key + Force number conversion
@@ -200,6 +215,7 @@ function customConfig (): CustomConfig {
       shortDescription: CONFIG.INSTANCE.SHORT_DESCRIPTION,
       description: CONFIG.INSTANCE.DESCRIPTION,
       terms: CONFIG.INSTANCE.TERMS,
+      isNSFW: CONFIG.INSTANCE.IS_NSFW,
       defaultClientRoute: CONFIG.INSTANCE.DEFAULT_CLIENT_ROUTE,
       defaultNSFWPolicy: CONFIG.INSTANCE.DEFAULT_NSFW_POLICY,
       customizations: {
@@ -246,6 +262,9 @@ function customConfig (): CustomConfig {
         '480p': CONFIG.TRANSCODING.RESOLUTIONS[ '480p' ],
         '720p': CONFIG.TRANSCODING.RESOLUTIONS[ '720p' ],
         '1080p': CONFIG.TRANSCODING.RESOLUTIONS[ '1080p' ]
+      },
+      hls: {
+        enabled: CONFIG.TRANSCODING.HLS.ENABLED
       }
     },
     import: {
@@ -257,6 +276,19 @@ function customConfig (): CustomConfig {
           enabled: CONFIG.IMPORT.VIDEOS.TORRENT.ENABLED
         }
       }
+    },
+    autoBlacklist: {
+      videos: {
+        ofUsers: {
+          enabled: CONFIG.AUTO_BLACKLIST.VIDEOS.OF_USERS.ENABLED
+        }
+      }
+    },
+    followers: {
+      instance: {
+        enabled: CONFIG.FOLLOWERS.INSTANCE.ENABLED,
+        manualApproval: CONFIG.FOLLOWERS.INSTANCE.MANUAL_APPROVAL
+      }
     }
   }
 }
diff --git a/server/controllers/api/index.ts b/server/controllers/api/index.ts
index 8a58b5466..60a84036e 100644
--- a/server/controllers/api/index.ts
+++ b/server/controllers/api/index.ts
@@ -11,6 +11,7 @@ import { videoChannelRouter } from './video-channel'
 import * as cors from 'cors'
 import { searchRouter } from './search'
 import { overviewsRouter } from './overviews'
+import { videoPlaylistRouter } from './video-playlist'
 
 const apiRouter = express.Router()
 
@@ -26,6 +27,7 @@ apiRouter.use('/config', configRouter)
 apiRouter.use('/users', usersRouter)
 apiRouter.use('/accounts', accountsRouter)
 apiRouter.use('/video-channels', videoChannelRouter)
+apiRouter.use('/video-playlists', videoPlaylistRouter)
 apiRouter.use('/videos', videosRouter)
 apiRouter.use('/jobs', jobsRouter)
 apiRouter.use('/search', searchRouter)
@@ -39,6 +41,6 @@ export { apiRouter }
 
 // ---------------------------------------------------------------------------
 
-function pong (req: express.Request, res: express.Response, next: express.NextFunction) {
+function pong (req: express.Request, res: express.Response) {
   return res.send('pong').status(200).end()
 }
diff --git a/server/controllers/api/oauth-clients.ts b/server/controllers/api/oauth-clients.ts
index 3dcc023e6..b2de8bcf5 100644
--- a/server/controllers/api/oauth-clients.ts
+++ b/server/controllers/api/oauth-clients.ts
@@ -1,7 +1,7 @@
 import * as express from 'express'
 import { OAuthClientLocal } from '../../../shared'
 import { logger } from '../../helpers/logger'
-import { CONFIG } from '../../initializers'
+import { CONFIG } from '../../initializers/config'
 import { asyncMiddleware } from '../../middlewares'
 import { OAuthClientModel } from '../../models/oauth/oauth-client'
 
diff --git a/server/controllers/api/overviews.ts b/server/controllers/api/overviews.ts
index 8b6773056..37ac152db 100644
--- a/server/controllers/api/overviews.ts
+++ b/server/controllers/api/overviews.ts
@@ -4,7 +4,7 @@ import { VideoModel } from '../../models/video/video'
 import { asyncMiddleware } from '../../middlewares'
 import { TagModel } from '../../models/video/tag'
 import { VideosOverview } from '../../../shared/models/overviews'
-import { MEMOIZE_TTL, OVERVIEWS, ROUTE_CACHE_LIFETIME } from '../../initializers'
+import { MEMOIZE_TTL, OVERVIEWS, ROUTE_CACHE_LIFETIME } from '../../initializers/constants'
 import { cacheRoute } from '../../middlewares/cache'
 import * as memoizee from 'memoizee'
 
@@ -94,7 +94,7 @@ async function getVideos (
 ) {
   const query = Object.assign({
     start: 0,
-    count: 10,
+    count: 12,
     sort: '-createdAt',
     includeLocalVideos: true,
     nsfw: buildNSFWFilter(res),
diff --git a/server/controllers/api/server/debug.ts b/server/controllers/api/server/debug.ts
new file mode 100644
index 000000000..4450038f6
--- /dev/null
+++ b/server/controllers/api/server/debug.ts
@@ -0,0 +1,25 @@
+import * as express from 'express'
+import { UserRight } from '../../../../shared/models/users'
+import { asyncMiddleware, authenticate, ensureUserHasRight } from '../../../middlewares'
+
+const debugRouter = express.Router()
+
+debugRouter.get('/debug',
+  authenticate,
+  ensureUserHasRight(UserRight.MANAGE_DEBUG),
+  asyncMiddleware(getDebug)
+)
+
+// ---------------------------------------------------------------------------
+
+export {
+  debugRouter
+}
+
+// ---------------------------------------------------------------------------
+
+async function getDebug (req: express.Request, res: express.Response) {
+  return res.json({
+    ip: req.ip
+  }).end()
+}
diff --git a/server/controllers/api/server/follows.ts b/server/controllers/api/server/follows.ts
index 9fa6c34ba..d38ce91de 100644
--- a/server/controllers/api/server/follows.ts
+++ b/server/controllers/api/server/follows.ts
@@ -2,22 +2,29 @@ import * as express from 'express'
 import { UserRight } from '../../../../shared/models/users'
 import { logger } from '../../../helpers/logger'
 import { getFormattedObjects, getServerActor } from '../../../helpers/utils'
-import { sequelizeTypescript, SERVER_ACTOR_NAME } from '../../../initializers'
-import { sendUndoFollow } from '../../../lib/activitypub/send'
+import { SERVER_ACTOR_NAME } from '../../../initializers/constants'
+import { sendAccept, sendReject, sendUndoFollow } from '../../../lib/activitypub/send'
 import {
   asyncMiddleware,
   authenticate,
   ensureUserHasRight,
   paginationValidator,
-  removeFollowingValidator,
   setBodyHostsPort,
   setDefaultPagination,
   setDefaultSort
 } from '../../../middlewares'
-import { followersSortValidator, followingSortValidator, followValidator } from '../../../middlewares/validators'
+import {
+  acceptOrRejectFollowerValidator,
+  followersSortValidator,
+  followingSortValidator,
+  followValidator,
+  getFollowerValidator,
+  removeFollowingValidator
+} from '../../../middlewares/validators'
 import { ActorFollowModel } from '../../../models/activitypub/actor-follow'
 import { JobQueue } from '../../../lib/job-queue'
 import { removeRedundancyOf } from '../../../lib/redundancy'
+import { sequelizeTypescript } from '../../../initializers/database'
 
 const serverFollowsRouter = express.Router()
 serverFollowsRouter.get('/following',
@@ -40,7 +47,7 @@ serverFollowsRouter.delete('/following/:host',
   authenticate,
   ensureUserHasRight(UserRight.MANAGE_SERVER_FOLLOW),
   asyncMiddleware(removeFollowingValidator),
-  asyncMiddleware(removeFollow)
+  asyncMiddleware(removeFollowing)
 )
 
 serverFollowsRouter.get('/followers',
@@ -51,6 +58,29 @@ serverFollowsRouter.get('/followers',
   asyncMiddleware(listFollowers)
 )
 
+serverFollowsRouter.delete('/followers/:nameWithHost',
+  authenticate,
+  ensureUserHasRight(UserRight.MANAGE_SERVER_FOLLOW),
+  asyncMiddleware(getFollowerValidator),
+  asyncMiddleware(removeOrRejectFollower)
+)
+
+serverFollowsRouter.post('/followers/:nameWithHost/reject',
+  authenticate,
+  ensureUserHasRight(UserRight.MANAGE_SERVER_FOLLOW),
+  asyncMiddleware(getFollowerValidator),
+  acceptOrRejectFollowerValidator,
+  asyncMiddleware(removeOrRejectFollower)
+)
+
+serverFollowsRouter.post('/followers/:nameWithHost/accept',
+  authenticate,
+  ensureUserHasRight(UserRight.MANAGE_SERVER_FOLLOW),
+  asyncMiddleware(getFollowerValidator),
+  acceptOrRejectFollowerValidator,
+  asyncMiddleware(acceptFollower)
+)
+
 // ---------------------------------------------------------------------------
 
 export {
@@ -59,7 +89,7 @@ export {
 
 // ---------------------------------------------------------------------------
 
-async function listFollowing (req: express.Request, res: express.Response, next: express.NextFunction) {
+async function listFollowing (req: express.Request, res: express.Response) {
   const serverActor = await getServerActor()
   const resultList = await ActorFollowModel.listFollowingForApi(
     serverActor.id,
@@ -72,7 +102,7 @@ async function listFollowing (req: express.Request, res: express.Response, next:
   return res.json(getFormattedObjects(resultList.data, resultList.total))
 }
 
-async function listFollowers (req: express.Request, res: express.Response, next: express.NextFunction) {
+async function listFollowers (req: express.Request, res: express.Response) {
   const serverActor = await getServerActor()
   const resultList = await ActorFollowModel.listFollowersForApi(
     serverActor.id,
@@ -85,7 +115,7 @@ async function listFollowers (req: express.Request, res: express.Response, next:
   return res.json(getFormattedObjects(resultList.data, resultList.total))
 }
 
-async function followInstance (req: express.Request, res: express.Response, next: express.NextFunction) {
+async function followInstance (req: express.Request, res: express.Response) {
   const hosts = req.body.hosts as string[]
   const follower = await getServerActor()
 
@@ -103,8 +133,8 @@ async function followInstance (req: express.Request, res: express.Response, next
   return res.status(204).end()
 }
 
-async function removeFollow (req: express.Request, res: express.Response, next: express.NextFunction) {
-  const follow: ActorFollowModel = res.locals.follow
+async function removeFollowing (req: express.Request, res: express.Response) {
+  const follow = res.locals.follow
 
   await sequelizeTypescript.transaction(async t => {
     if (follow.state === 'accepted') await sendUndoFollow(follow, t)
@@ -123,3 +153,24 @@ async function removeFollow (req: express.Request, res: express.Response, next:
 
   return res.status(204).end()
 }
+
+async function removeOrRejectFollower (req: express.Request, res: express.Response) {
+  const follow = res.locals.follow
+
+  await sendReject(follow.ActorFollower, follow.ActorFollowing)
+
+  await follow.destroy()
+
+  return res.status(204).end()
+}
+
+async function acceptFollower (req: express.Request, res: express.Response) {
+  const follow = res.locals.follow
+
+  await sendAccept(follow)
+
+  follow.state = 'accepted'
+  await follow.save()
+
+  return res.status(204).end()
+}
diff --git a/server/controllers/api/server/index.ts b/server/controllers/api/server/index.ts
index 814248e5f..6b8793a19 100644
--- a/server/controllers/api/server/index.ts
+++ b/server/controllers/api/server/index.ts
@@ -4,6 +4,8 @@ import { statsRouter } from './stats'
 import { serverRedundancyRouter } from './redundancy'
 import { serverBlocklistRouter } from './server-blocklist'
 import { contactRouter } from './contact'
+import { logsRouter } from './logs'
+import { debugRouter } from './debug'
 
 const serverRouter = express.Router()
 
@@ -12,6 +14,8 @@ serverRouter.use('/', serverRedundancyRouter)
 serverRouter.use('/', statsRouter)
 serverRouter.use('/', serverBlocklistRouter)
 serverRouter.use('/', contactRouter)
+serverRouter.use('/', logsRouter)
+serverRouter.use('/', debugRouter)
 
 // ---------------------------------------------------------------------------
 
diff --git a/server/controllers/api/server/logs.ts b/server/controllers/api/server/logs.ts
new file mode 100644
index 000000000..e9d1f2efd
--- /dev/null
+++ b/server/controllers/api/server/logs.ts
@@ -0,0 +1,95 @@
+import * as express from 'express'
+import { UserRight } from '../../../../shared/models/users'
+import { asyncMiddleware, authenticate, ensureUserHasRight } from '../../../middlewares'
+import { mtimeSortFilesDesc } from '../../../../shared/core-utils/logs/logs'
+import { readdir, readFile } from 'fs-extra'
+import { MAX_LOGS_OUTPUT_CHARACTERS } from '../../../initializers/constants'
+import { join } from 'path'
+import { getLogsValidator } from '../../../middlewares/validators/logs'
+import { LogLevel } from '../../../../shared/models/server/log-level.type'
+import { CONFIG } from '../../../initializers/config'
+
+const logsRouter = express.Router()
+
+logsRouter.get('/logs',
+  authenticate,
+  ensureUserHasRight(UserRight.MANAGE_LOGS),
+  getLogsValidator,
+  asyncMiddleware(getLogs)
+)
+
+// ---------------------------------------------------------------------------
+
+export {
+  logsRouter
+}
+
+// ---------------------------------------------------------------------------
+
+async function getLogs (req: express.Request, res: express.Response) {
+  const logFiles = await readdir(CONFIG.STORAGE.LOG_DIR)
+  const sortedLogFiles = await mtimeSortFilesDesc(logFiles, CONFIG.STORAGE.LOG_DIR)
+  let currentSize = 0
+
+  const startDate = new Date(req.query.startDate)
+  const endDate = req.query.endDate ? new Date(req.query.endDate) : new Date()
+  const level: LogLevel = req.query.level || 'info'
+
+  let output: string[] = []
+
+  for (const meta of sortedLogFiles) {
+    const path = join(CONFIG.STORAGE.LOG_DIR, meta.file)
+
+    const result = await getOutputFromFile(path, startDate, endDate, level, currentSize)
+    if (!result.output) break
+
+    output = result.output.concat(output)
+    currentSize = result.currentSize
+
+    if (currentSize > MAX_LOGS_OUTPUT_CHARACTERS || (result.logTime && result.logTime < startDate.getTime())) break
+  }
+
+  return res.json(output).end()
+}
+
+async function getOutputFromFile (path: string, startDate: Date, endDate: Date, level: LogLevel, currentSize: number) {
+  const startTime = startDate.getTime()
+  const endTime = endDate.getTime()
+  let logTime: number
+
+  const logsLevel: { [ id in LogLevel ]: number } = {
+    debug: 0,
+    info: 1,
+    warn: 2,
+    error: 3
+  }
+
+  const content = await readFile(path)
+  const lines = content.toString().split('\n')
+  const output: any[] = []
+
+  for (let i = lines.length - 1; i >= 0; i--) {
+    const line = lines[ i ]
+    let log: any
+
+    try {
+      log = JSON.parse(line)
+    } catch {
+      // Maybe there a multiple \n at the end of the file
+      continue
+    }
+
+    logTime = new Date(log.timestamp).getTime()
+    if (logTime >= startTime && logTime <= endTime && logsLevel[ log.level ] >= logsLevel[ level ]) {
+      output.push(log)
+
+      currentSize += line.length
+
+      if (currentSize > MAX_LOGS_OUTPUT_CHARACTERS) break
+    } else if (logTime < startTime) {
+      break
+    }
+  }
+
+  return { currentSize, output: output.reverse(), logTime }
+}
diff --git a/server/controllers/api/server/redundancy.ts b/server/controllers/api/server/redundancy.ts
index 4140c4991..f8109070d 100644
--- a/server/controllers/api/server/redundancy.ts
+++ b/server/controllers/api/server/redundancy.ts
@@ -2,7 +2,6 @@ import * as express from 'express'
 import { UserRight } from '../../../../shared/models/users'
 import { asyncMiddleware, authenticate, ensureUserHasRight } from '../../../middlewares'
 import { updateServerRedundancyValidator } from '../../../middlewares/validators/redundancy'
-import { ServerModel } from '../../../models/server/server'
 import { removeRedundancyOf } from '../../../lib/redundancy'
 import { logger } from '../../../helpers/logger'
 
@@ -23,8 +22,8 @@ export {
 
 // ---------------------------------------------------------------------------
 
-async function updateRedundancy (req: express.Request, res: express.Response, next: express.NextFunction) {
-  const server = res.locals.server as ServerModel
+async function updateRedundancy (req: express.Request, res: express.Response) {
+  const server = res.locals.server
 
   server.redundancyAllowed = req.body.redundancyAllowed
 
diff --git a/server/controllers/api/server/server-blocklist.ts b/server/controllers/api/server/server-blocklist.ts
index 3cb3a96e2..d165db191 100644
--- a/server/controllers/api/server/server-blocklist.ts
+++ b/server/controllers/api/server/server-blocklist.ts
@@ -18,11 +18,9 @@ import {
   unblockAccountByServerValidator,
   unblockServerByServerValidator
 } from '../../../middlewares/validators'
-import { AccountModel } from '../../../models/account/account'
 import { AccountBlocklistModel } from '../../../models/account/account-blocklist'
 import { addAccountInBlocklist, addServerInBlocklist, removeAccountFromBlocklist, removeServerFromBlocklist } from '../../../lib/blocklist'
 import { ServerBlocklistModel } from '../../../models/server/server-blocklist'
-import { ServerModel } from '../../../models/server/server'
 import { UserRight } from '../../../../shared/models/users'
 
 const serverBlocklistRouter = express.Router()
@@ -91,7 +89,7 @@ async function listBlockedAccounts (req: express.Request, res: express.Response)
 
 async function blockAccount (req: express.Request, res: express.Response) {
   const serverActor = await getServerActor()
-  const accountToBlock: AccountModel = res.locals.account
+  const accountToBlock = res.locals.account
 
   await addAccountInBlocklist(serverActor.Account.id, accountToBlock.id)
 
@@ -99,7 +97,7 @@ async function blockAccount (req: express.Request, res: express.Response) {
 }
 
 async function unblockAccount (req: express.Request, res: express.Response) {
-  const accountBlock: AccountBlocklistModel = res.locals.accountBlock
+  const accountBlock = res.locals.accountBlock
 
   await removeAccountFromBlocklist(accountBlock)
 
@@ -116,7 +114,7 @@ async function listBlockedServers (req: express.Request, res: express.Response)
 
 async function blockServer (req: express.Request, res: express.Response) {
   const serverActor = await getServerActor()
-  const serverToBlock: ServerModel = res.locals.server
+  const serverToBlock = res.locals.server
 
   await addServerInBlocklist(serverActor.Account.id, serverToBlock.id)
 
@@ -124,7 +122,7 @@ async function blockServer (req: express.Request, res: express.Response) {
 }
 
 async function unblockServer (req: express.Request, res: express.Response) {
-  const serverBlock: ServerBlocklistModel = res.locals.serverBlock
+  const serverBlock = res.locals.serverBlock
 
   await removeServerFromBlocklist(serverBlock)
 
diff --git a/server/controllers/api/server/stats.ts b/server/controllers/api/server/stats.ts
index 89ffd1717..951b98209 100644
--- a/server/controllers/api/server/stats.ts
+++ b/server/controllers/api/server/stats.ts
@@ -6,9 +6,10 @@ import { ActorFollowModel } from '../../../models/activitypub/actor-follow'
 import { VideoModel } from '../../../models/video/video'
 import { VideoCommentModel } from '../../../models/video/video-comment'
 import { VideoRedundancyModel } from '../../../models/redundancy/video-redundancy'
-import { CONFIG, ROUTE_CACHE_LIFETIME } from '../../../initializers/constants'
+import { ROUTE_CACHE_LIFETIME } from '../../../initializers/constants'
 import { cacheRoute } from '../../../middlewares/cache'
 import { VideoFileModel } from '../../../models/video/video-file'
+import { CONFIG } from '../../../initializers/config'
 
 const statsRouter = express.Router()
 
diff --git a/server/controllers/api/users/index.ts b/server/controllers/api/users/index.ts
index dbe0718d4..0aafba66e 100644
--- a/server/controllers/api/users/index.ts
+++ b/server/controllers/api/users/index.ts
@@ -3,10 +3,10 @@ import * as RateLimit from 'express-rate-limit'
 import { UserCreate, UserRight, UserRole, UserUpdate } from '../../../../shared'
 import { logger } from '../../../helpers/logger'
 import { getFormattedObjects } from '../../../helpers/utils'
-import { CONFIG, RATES_LIMIT, sequelizeTypescript } from '../../../initializers'
+import { RATES_LIMIT, WEBSERVER } from '../../../initializers/constants'
 import { Emailer } from '../../../lib/emailer'
 import { Redis } from '../../../lib/redis'
-import { createUserAccountAndChannel } from '../../../lib/user'
+import { createUserAccountAndChannelAndPlaylist } from '../../../lib/user'
 import {
   asyncMiddleware,
   asyncRetryTransactionMiddleware,
@@ -38,23 +38,25 @@ import { auditLoggerFactory, getAuditIdFromRes, UserAuditView } from '../../../h
 import { meRouter } from './me'
 import { deleteUserToken } from '../../../lib/oauth-model'
 import { myBlocklistRouter } from './my-blocklist'
+import { myVideoPlaylistsRouter } from './my-video-playlists'
 import { myVideosHistoryRouter } from './my-history'
 import { myNotificationsRouter } from './my-notifications'
 import { Notifier } from '../../../lib/notifier'
 import { mySubscriptionsRouter } from './my-subscriptions'
+import { CONFIG } from '../../../initializers/config'
+import { sequelizeTypescript } from '../../../initializers/database'
+import { UserAdminFlag } from '../../../../shared/models/users/user-flag.model'
 
 const auditLogger = auditLoggerFactory('users')
 
 const loginRateLimiter = new RateLimit({
   windowMs: RATES_LIMIT.LOGIN.WINDOW_MS,
-  max: RATES_LIMIT.LOGIN.MAX,
-  delayMs: 0
+  max: RATES_LIMIT.LOGIN.MAX
 })
 
 const askSendEmailLimiter = new RateLimit({
   windowMs: RATES_LIMIT.ASK_SEND_EMAIL.WINDOW_MS,
-  max: RATES_LIMIT.ASK_SEND_EMAIL.MAX,
-  delayMs: 0
+  max: RATES_LIMIT.ASK_SEND_EMAIL.MAX
 })
 
 const usersRouter = express.Router()
@@ -62,6 +64,7 @@ usersRouter.use('/', myNotificationsRouter)
 usersRouter.use('/', mySubscriptionsRouter)
 usersRouter.use('/', myBlocklistRouter)
 usersRouter.use('/', myVideosHistoryRouter)
+usersRouter.use('/', myVideoPlaylistsRouter)
 usersRouter.use('/', meRouter)
 
 usersRouter.get('/autocomplete',
@@ -173,10 +176,11 @@ async function createUser (req: express.Request, res: express.Response) {
     autoPlayVideo: true,
     role: body.role,
     videoQuota: body.videoQuota,
-    videoQuotaDaily: body.videoQuotaDaily
+    videoQuotaDaily: body.videoQuotaDaily,
+    adminFlags: body.adminFlags || UserAdminFlag.NONE
   })
 
-  const { user, account } = await createUserAccountAndChannel(userToCreate)
+  const { user, account } = await createUserAccountAndChannelAndPlaylist(userToCreate)
 
   auditLogger.create(getAuditIdFromRes(res), new UserAuditView(user.toFormattedJSON()))
   logger.info('User %s with its channel and account created.', body.username)
@@ -207,7 +211,7 @@ async function registerUser (req: express.Request, res: express.Response) {
     emailVerified: CONFIG.SIGNUP.REQUIRES_EMAIL_VERIFICATION ? false : null
   })
 
-  const { user } = await createUserAccountAndChannel(userToCreate)
+  const { user } = await createUserAccountAndChannelAndPlaylist(userToCreate)
 
   auditLogger.create(body.username, new UserAuditView(user.toFormattedJSON()))
   logger.info('User %s with its channel and account registered.', body.username)
@@ -221,16 +225,16 @@ async function registerUser (req: express.Request, res: express.Response) {
   return res.type('json').status(204).end()
 }
 
-async function unblockUser (req: express.Request, res: express.Response, next: express.NextFunction) {
-  const user: UserModel = res.locals.user
+async function unblockUser (req: express.Request, res: express.Response) {
+  const user = res.locals.user
 
   await changeUserBlock(res, user, false)
 
   return res.status(204).end()
 }
 
-async function blockUser (req: express.Request, res: express.Response, next: express.NextFunction) {
-  const user: UserModel = res.locals.user
+async function blockUser (req: express.Request, res: express.Response) {
+  const user = res.locals.user
   const reason = req.body.reason
 
   await changeUserBlock(res, user, true, reason)
@@ -238,24 +242,24 @@ async function blockUser (req: express.Request, res: express.Response, next: exp
   return res.status(204).end()
 }
 
-function getUser (req: express.Request, res: express.Response, next: express.NextFunction) {
-  return res.json((res.locals.user as UserModel).toFormattedJSON())
+function getUser (req: express.Request, res: express.Response) {
+  return res.json(res.locals.user.toFormattedJSON({ withAdminFlags: true }))
 }
 
-async function autocompleteUsers (req: express.Request, res: express.Response, next: express.NextFunction) {
+async function autocompleteUsers (req: express.Request, res: express.Response) {
   const resultList = await UserModel.autoComplete(req.query.search as string)
 
   return res.json(resultList)
 }
 
-async function listUsers (req: express.Request, res: express.Response, next: express.NextFunction) {
+async function listUsers (req: express.Request, res: express.Response) {
   const resultList = await UserModel.listForApi(req.query.start, req.query.count, req.query.sort, req.query.search)
 
-  return res.json(getFormattedObjects(resultList.data, resultList.total))
+  return res.json(getFormattedObjects(resultList.data, resultList.total, { withAdminFlags: true }))
 }
 
-async function removeUser (req: express.Request, res: express.Response, next: express.NextFunction) {
-  const user: UserModel = res.locals.user
+async function removeUser (req: express.Request, res: express.Response) {
+  const user = res.locals.user
 
   await user.destroy()
 
@@ -264,42 +268,44 @@ async function removeUser (req: express.Request, res: express.Response, next: ex
   return res.sendStatus(204)
 }
 
-async function updateUser (req: express.Request, res: express.Response, next: express.NextFunction) {
+async function updateUser (req: express.Request, res: express.Response) {
   const body: UserUpdate = req.body
-  const userToUpdate = res.locals.user as UserModel
+  const userToUpdate = res.locals.user
   const oldUserAuditView = new UserAuditView(userToUpdate.toFormattedJSON())
   const roleChanged = body.role !== undefined && body.role !== userToUpdate.role
 
+  if (body.password !== undefined) userToUpdate.password = body.password
   if (body.email !== undefined) userToUpdate.email = body.email
   if (body.emailVerified !== undefined) userToUpdate.emailVerified = body.emailVerified
   if (body.videoQuota !== undefined) userToUpdate.videoQuota = body.videoQuota
   if (body.videoQuotaDaily !== undefined) userToUpdate.videoQuotaDaily = body.videoQuotaDaily
   if (body.role !== undefined) userToUpdate.role = body.role
+  if (body.adminFlags !== undefined) userToUpdate.adminFlags = body.adminFlags
 
   const user = await userToUpdate.save()
 
   // Destroy user token to refresh rights
-  if (roleChanged) await deleteUserToken(userToUpdate.id)
+  if (roleChanged || body.password !== undefined) await deleteUserToken(userToUpdate.id)
 
   auditLogger.update(getAuditIdFromRes(res), new UserAuditView(user.toFormattedJSON()), oldUserAuditView)
 
-  // Don't need to send this update to followers, these attributes are not propagated
+  // Don't need to send this update to followers, these attributes are not federated
 
   return res.sendStatus(204)
 }
 
-async function askResetUserPassword (req: express.Request, res: express.Response, next: express.NextFunction) {
-  const user = res.locals.user as UserModel
+async function askResetUserPassword (req: express.Request, res: express.Response) {
+  const user = res.locals.user
 
   const verificationString = await Redis.Instance.setResetPasswordVerificationString(user.id)
-  const url = CONFIG.WEBSERVER.URL + '/reset-password?userId=' + user.id + '&verificationString=' + verificationString
-  await Emailer.Instance.addForgetPasswordEmailJob(user.email, url)
+  const url = WEBSERVER.URL + '/reset-password?userId=' + user.id + '&verificationString=' + verificationString
+  await Emailer.Instance.addPasswordResetEmailJob(user.email, url)
 
   return res.status(204).end()
 }
 
-async function resetUserPassword (req: express.Request, res: express.Response, next: express.NextFunction) {
-  const user = res.locals.user as UserModel
+async function resetUserPassword (req: express.Request, res: express.Response) {
+  const user = res.locals.user
   user.password = req.body.password
 
   await user.save()
@@ -309,21 +315,21 @@ async function resetUserPassword (req: express.Request, res: express.Response, n
 
 async function sendVerifyUserEmail (user: UserModel) {
   const verificationString = await Redis.Instance.setVerifyEmailVerificationString(user.id)
-  const url = CONFIG.WEBSERVER.URL + '/verify-account/email?userId=' + user.id + '&verificationString=' + verificationString
+  const url = WEBSERVER.URL + '/verify-account/email?userId=' + user.id + '&verificationString=' + verificationString
   await Emailer.Instance.addVerifyEmailJob(user.email, url)
   return
 }
 
-async function askSendVerifyUserEmail (req: express.Request, res: express.Response, next: express.NextFunction) {
-  const user = res.locals.user as UserModel
+async function askSendVerifyUserEmail (req: express.Request, res: express.Response) {
+  const user = res.locals.user
 
   await sendVerifyUserEmail(user)
 
   return res.status(204).end()
 }
 
-async function verifyUserEmail (req: express.Request, res: express.Response, next: express.NextFunction) {
-  const user = res.locals.user as UserModel
+async function verifyUserEmail (req: express.Request, res: express.Response) {
+  const user = res.locals.user
   user.emailVerified = true
 
   await user.save()
@@ -331,7 +337,7 @@ async function verifyUserEmail (req: express.Request, res: express.Response, nex
   return res.status(204).end()
 }
 
-function success (req: express.Request, res: express.Response, next: express.NextFunction) {
+function success (req: express.Request, res: express.Response) {
   res.end()
 }
 
diff --git a/server/controllers/api/users/me.ts b/server/controllers/api/users/me.ts
index 94a2b8732..ddb239e7b 100644
--- a/server/controllers/api/users/me.ts
+++ b/server/controllers/api/users/me.ts
@@ -2,7 +2,7 @@ import * as express from 'express'
 import 'multer'
 import { UserUpdateMe, UserVideoRate as FormattedUserVideoRate } from '../../../../shared'
 import { getFormattedObjects } from '../../../helpers/utils'
-import { CONFIG, MIMETYPES, sequelizeTypescript } from '../../../initializers'
+import { MIMETYPES } from '../../../initializers/constants'
 import { sendUpdateActor } from '../../../lib/activitypub/send'
 import {
   asyncMiddleware,
@@ -26,6 +26,8 @@ import { updateActorAvatarFile } from '../../../lib/avatar'
 import { auditLoggerFactory, getAuditIdFromRes, UserAuditView } from '../../../helpers/audit-logger'
 import { VideoImportModel } from '../../../models/video/video-import'
 import { AccountModel } from '../../../models/account/account'
+import { CONFIG } from '../../../initializers/config'
+import { sequelizeTypescript } from '../../../initializers/database'
 
 const auditLogger = auditLoggerFactory('users-me')
 
@@ -93,8 +95,8 @@ export {
 
 // ---------------------------------------------------------------------------
 
-async function getUserVideos (req: express.Request, res: express.Response, next: express.NextFunction) {
-  const user = res.locals.oauth.token.User as UserModel
+async function getUserVideos (req: express.Request, res: express.Response) {
+  const user = res.locals.oauth.token.User
   const resultList = await VideoModel.listUserVideosForApi(
     user.Account.id,
     req.query.start as number,
@@ -111,8 +113,8 @@ async function getUserVideos (req: express.Request, res: express.Response, next:
   return res.json(getFormattedObjects(resultList.data, resultList.total, { additionalAttributes }))
 }
 
-async function getUserVideoImports (req: express.Request, res: express.Response, next: express.NextFunction) {
-  const user = res.locals.oauth.token.User as UserModel
+async function getUserVideoImports (req: express.Request, res: express.Response) {
+  const user = res.locals.oauth.token.User
   const resultList = await VideoImportModel.listUserVideoImportsForApi(
     user.id,
     req.query.start as number,
@@ -123,14 +125,14 @@ async function getUserVideoImports (req: express.Request, res: express.Response,
   return res.json(getFormattedObjects(resultList.data, resultList.total))
 }
 
-async function getUserInformation (req: express.Request, res: express.Response, next: express.NextFunction) {
+async function getUserInformation (req: express.Request, res: express.Response) {
   // We did not load channels in res.locals.user
   const user = await UserModel.loadByUsernameAndPopulateChannels(res.locals.oauth.token.user.username)
 
-  return res.json(user.toFormattedJSON())
+  return res.json(user.toFormattedJSON({}))
 }
 
-async function getUserVideoQuotaUsed (req: express.Request, res: express.Response, next: express.NextFunction) {
+async function getUserVideoQuotaUsed (req: express.Request, res: express.Response) {
   // We did not load channels in res.locals.user
   const user = await UserModel.loadByUsernameAndPopulateChannels(res.locals.oauth.token.user.username)
   const videoQuotaUsed = await UserModel.getOriginalVideoFileTotalFromUser(user)
@@ -143,7 +145,7 @@ async function getUserVideoQuotaUsed (req: express.Request, res: express.Respons
   return res.json(data)
 }
 
-async function getUserVideoRating (req: express.Request, res: express.Response, next: express.NextFunction) {
+async function getUserVideoRating (req: express.Request, res: express.Response) {
   const videoId = res.locals.video.id
   const accountId = +res.locals.oauth.token.User.Account.id
 
@@ -158,20 +160,20 @@ async function getUserVideoRating (req: express.Request, res: express.Response,
 }
 
 async function deleteMe (req: express.Request, res: express.Response) {
-  const user: UserModel = res.locals.oauth.token.User
+  const user = res.locals.oauth.token.User
 
   await user.destroy()
 
-  auditLogger.delete(getAuditIdFromRes(res), new UserAuditView(user.toFormattedJSON()))
+  auditLogger.delete(getAuditIdFromRes(res), new UserAuditView(user.toFormattedJSON({})))
 
   return res.sendStatus(204)
 }
 
-async function updateMe (req: express.Request, res: express.Response, next: express.NextFunction) {
+async function updateMe (req: express.Request, res: express.Response) {
   const body: UserUpdateMe = req.body
 
-  const user: UserModel = res.locals.oauth.token.user
-  const oldUserAuditView = new UserAuditView(user.toFormattedJSON())
+  const user = res.locals.oauth.token.user
+  const oldUserAuditView = new UserAuditView(user.toFormattedJSON({}))
 
   if (body.password !== undefined) user.password = body.password
   if (body.email !== undefined) user.email = body.email
@@ -191,7 +193,7 @@ async function updateMe (req: express.Request, res: express.Response, next: expr
 
     await sendUpdateActor(userAccount, t)
 
-    auditLogger.update(getAuditIdFromRes(res), new UserAuditView(user.toFormattedJSON()), oldUserAuditView)
+    auditLogger.update(getAuditIdFromRes(res), new UserAuditView(user.toFormattedJSON({})), oldUserAuditView)
   })
 
   return res.sendStatus(204)
@@ -199,14 +201,14 @@ async function updateMe (req: express.Request, res: express.Response, next: expr
 
 async function updateMyAvatar (req: express.Request, res: express.Response) {
   const avatarPhysicalFile = req.files[ 'avatarfile' ][ 0 ]
-  const user: UserModel = res.locals.oauth.token.user
-  const oldUserAuditView = new UserAuditView(user.toFormattedJSON())
+  const user = res.locals.oauth.token.user
+  const oldUserAuditView = new UserAuditView(user.toFormattedJSON({}))
 
   const userAccount = await AccountModel.load(user.Account.id)
 
   const avatar = await updateActorAvatarFile(avatarPhysicalFile, userAccount)
 
-  auditLogger.update(getAuditIdFromRes(res), new UserAuditView(user.toFormattedJSON()), oldUserAuditView)
+  auditLogger.update(getAuditIdFromRes(res), new UserAuditView(user.toFormattedJSON({})), oldUserAuditView)
 
   return res.json({ avatar: avatar.toFormattedJSON() })
 }
diff --git a/server/controllers/api/users/my-blocklist.ts b/server/controllers/api/users/my-blocklist.ts
index 9575eab46..713c16022 100644
--- a/server/controllers/api/users/my-blocklist.ts
+++ b/server/controllers/api/users/my-blocklist.ts
@@ -17,12 +17,9 @@ import {
   serversBlocklistSortValidator,
   unblockServerByAccountValidator
 } from '../../../middlewares/validators'
-import { UserModel } from '../../../models/account/user'
-import { AccountModel } from '../../../models/account/account'
 import { AccountBlocklistModel } from '../../../models/account/account-blocklist'
 import { addAccountInBlocklist, addServerInBlocklist, removeAccountFromBlocklist, removeServerFromBlocklist } from '../../../lib/blocklist'
 import { ServerBlocklistModel } from '../../../models/server/server-blocklist'
-import { ServerModel } from '../../../models/server/server'
 
 const myBlocklistRouter = express.Router()
 
@@ -75,7 +72,7 @@ export {
 // ---------------------------------------------------------------------------
 
 async function listBlockedAccounts (req: express.Request, res: express.Response) {
-  const user: UserModel = res.locals.oauth.token.User
+  const user = res.locals.oauth.token.User
 
   const resultList = await AccountBlocklistModel.listForApi(user.Account.id, req.query.start, req.query.count, req.query.sort)
 
@@ -83,8 +80,8 @@ async function listBlockedAccounts (req: express.Request, res: express.Response)
 }
 
 async function blockAccount (req: express.Request, res: express.Response) {
-  const user: UserModel = res.locals.oauth.token.User
-  const accountToBlock: AccountModel = res.locals.account
+  const user = res.locals.oauth.token.User
+  const accountToBlock = res.locals.account
 
   await addAccountInBlocklist(user.Account.id, accountToBlock.id)
 
@@ -92,7 +89,7 @@ async function blockAccount (req: express.Request, res: express.Response) {
 }
 
 async function unblockAccount (req: express.Request, res: express.Response) {
-  const accountBlock: AccountBlocklistModel = res.locals.accountBlock
+  const accountBlock = res.locals.accountBlock
 
   await removeAccountFromBlocklist(accountBlock)
 
@@ -100,7 +97,7 @@ async function unblockAccount (req: express.Request, res: express.Response) {
 }
 
 async function listBlockedServers (req: express.Request, res: express.Response) {
-  const user: UserModel = res.locals.oauth.token.User
+  const user = res.locals.oauth.token.User
 
   const resultList = await ServerBlocklistModel.listForApi(user.Account.id, req.query.start, req.query.count, req.query.sort)
 
@@ -108,8 +105,8 @@ async function listBlockedServers (req: express.Request, res: express.Response)
 }
 
 async function blockServer (req: express.Request, res: express.Response) {
-  const user: UserModel = res.locals.oauth.token.User
-  const serverToBlock: ServerModel = res.locals.server
+  const user = res.locals.oauth.token.User
+  const serverToBlock = res.locals.server
 
   await addServerInBlocklist(user.Account.id, serverToBlock.id)
 
@@ -117,7 +114,7 @@ async function blockServer (req: express.Request, res: express.Response) {
 }
 
 async function unblockServer (req: express.Request, res: express.Response) {
-  const serverBlock: ServerBlocklistModel = res.locals.serverBlock
+  const serverBlock = res.locals.serverBlock
 
   await removeServerFromBlocklist(serverBlock)
 
diff --git a/server/controllers/api/users/my-history.ts b/server/controllers/api/users/my-history.ts
index 6cd782c47..7025c0ff1 100644
--- a/server/controllers/api/users/my-history.ts
+++ b/server/controllers/api/users/my-history.ts
@@ -36,7 +36,7 @@ export {
 // ---------------------------------------------------------------------------
 
 async function listMyVideosHistory (req: express.Request, res: express.Response) {
-  const user: UserModel = res.locals.oauth.token.User
+  const user = res.locals.oauth.token.User
 
   const resultList = await UserVideoHistoryModel.listForApi(user, req.query.start, req.query.count)
 
@@ -44,11 +44,11 @@ async function listMyVideosHistory (req: express.Request, res: express.Response)
 }
 
 async function removeUserHistory (req: express.Request, res: express.Response) {
-  const user: UserModel = res.locals.oauth.token.User
+  const user = res.locals.oauth.token.User
   const beforeDate = req.body.beforeDate || null
 
   await sequelizeTypescript.transaction(t => {
-    return UserVideoHistoryModel.removeHistoryBefore(user, beforeDate, t)
+    return UserVideoHistoryModel.removeUserHistoryBefore(user, beforeDate, t)
   })
 
   // Do not send the delete to other instances, we delete OUR copy of this video abuse
diff --git a/server/controllers/api/users/my-notifications.ts b/server/controllers/api/users/my-notifications.ts
index 76cf97587..f146284e4 100644
--- a/server/controllers/api/users/my-notifications.ts
+++ b/server/controllers/api/users/my-notifications.ts
@@ -9,7 +9,6 @@ import {
   setDefaultSort,
   userNotificationsSortValidator
 } from '../../../middlewares'
-import { UserModel } from '../../../models/account/user'
 import { getFormattedObjects } from '../../../helpers/utils'
 import { UserNotificationModel } from '../../../models/account/user-notification'
 import { meRouter } from './me'
@@ -57,8 +56,8 @@ export {
 // ---------------------------------------------------------------------------
 
 async function updateNotificationSettings (req: express.Request, res: express.Response) {
-  const user: UserModel = res.locals.oauth.token.User
-  const body = req.body
+  const user = res.locals.oauth.token.User
+  const body = req.body as UserNotificationSetting
 
   const query = {
     where: {
@@ -70,12 +69,14 @@ async function updateNotificationSettings (req: express.Request, res: express.Re
     newVideoFromSubscription: body.newVideoFromSubscription,
     newCommentOnMyVideo: body.newCommentOnMyVideo,
     videoAbuseAsModerator: body.videoAbuseAsModerator,
+    videoAutoBlacklistAsModerator: body.videoAutoBlacklistAsModerator,
     blacklistOnMyVideo: body.blacklistOnMyVideo,
     myVideoPublished: body.myVideoPublished,
     myVideoImportFinished: body.myVideoImportFinished,
     newFollow: body.newFollow,
     newUserRegistration: body.newUserRegistration,
-    commentMention: body.commentMention
+    commentMention: body.commentMention,
+    newInstanceFollower: body.newInstanceFollower
   }
 
   await UserNotificationSettingModel.update(values, query)
@@ -84,7 +85,7 @@ async function updateNotificationSettings (req: express.Request, res: express.Re
 }
 
 async function listUserNotifications (req: express.Request, res: express.Response) {
-  const user: UserModel = res.locals.oauth.token.User
+  const user = res.locals.oauth.token.User
 
   const resultList = await UserNotificationModel.listForApi(user.id, req.query.start, req.query.count, req.query.sort, req.query.unread)
 
@@ -92,7 +93,7 @@ async function listUserNotifications (req: express.Request, res: express.Respons
 }
 
 async function markAsReadUserNotifications (req: express.Request, res: express.Response) {
-  const user: UserModel = res.locals.oauth.token.User
+  const user = res.locals.oauth.token.User
 
   await UserNotificationModel.markAsRead(user.id, req.body.ids)
 
@@ -100,7 +101,7 @@ async function markAsReadUserNotifications (req: express.Request, res: express.R
 }
 
 async function markAsReadAllUserNotifications (req: express.Request, res: express.Response) {
-  const user: UserModel = res.locals.oauth.token.User
+  const user = res.locals.oauth.token.User
 
   await UserNotificationModel.markAllAsRead(user.id)
 
diff --git a/server/controllers/api/users/my-subscriptions.ts b/server/controllers/api/users/my-subscriptions.ts
index accca6d52..c52df3154 100644
--- a/server/controllers/api/users/my-subscriptions.ts
+++ b/server/controllers/api/users/my-subscriptions.ts
@@ -1,7 +1,7 @@
 import * as express from 'express'
 import 'multer'
 import { getFormattedObjects } from '../../../helpers/utils'
-import { CONFIG, sequelizeTypescript } from '../../../initializers'
+import { WEBSERVER } from '../../../initializers/constants'
 import {
   asyncMiddleware,
   asyncRetryTransactionMiddleware,
@@ -14,13 +14,13 @@ import {
   userSubscriptionGetValidator
 } from '../../../middlewares'
 import { areSubscriptionsExistValidator, userSubscriptionsSortValidator, videosSortValidator } from '../../../middlewares/validators'
-import { UserModel } from '../../../models/account/user'
 import { VideoModel } from '../../../models/video/video'
 import { buildNSFWFilter } from '../../../helpers/express-utils'
 import { VideoFilter } from '../../../../shared/models/videos/video-query.type'
 import { ActorFollowModel } from '../../../models/activitypub/actor-follow'
 import { JobQueue } from '../../../lib/job-queue'
 import { logger } from '../../../helpers/logger'
+import { sequelizeTypescript } from '../../../initializers/database'
 
 const mySubscriptionsRouter = express.Router()
 
@@ -77,11 +77,11 @@ export {
 
 async function areSubscriptionsExist (req: express.Request, res: express.Response) {
   const uris = req.query.uris as string[]
-  const user = res.locals.oauth.token.User as UserModel
+  const user = res.locals.oauth.token.User
 
   const handles = uris.map(u => {
     let [ name, host ] = u.split('@')
-    if (host === CONFIG.WEBSERVER.HOST) host = null
+    if (host === WEBSERVER.HOST) host = null
 
     return { name, host, uri: u }
   })
@@ -107,7 +107,7 @@ async function areSubscriptionsExist (req: express.Request, res: express.Respons
 }
 
 async function addUserSubscription (req: express.Request, res: express.Response) {
-  const user = res.locals.oauth.token.User as UserModel
+  const user = res.locals.oauth.token.User
   const [ name, host ] = req.body.uri.split('@')
 
   const payload = {
@@ -123,13 +123,13 @@ async function addUserSubscription (req: express.Request, res: express.Response)
 }
 
 function getUserSubscription (req: express.Request, res: express.Response) {
-  const subscription: ActorFollowModel = res.locals.subscription
+  const subscription = res.locals.subscription
 
   return res.json(subscription.ActorFollowing.VideoChannel.toFormattedJSON())
 }
 
 async function deleteUserSubscription (req: express.Request, res: express.Response) {
-  const subscription: ActorFollowModel = res.locals.subscription
+  const subscription = res.locals.subscription
 
   await sequelizeTypescript.transaction(async t => {
     return subscription.destroy({ transaction: t })
@@ -139,7 +139,7 @@ async function deleteUserSubscription (req: express.Request, res: express.Respon
 }
 
 async function getUserSubscriptions (req: express.Request, res: express.Response) {
-  const user = res.locals.oauth.token.User as UserModel
+  const user = res.locals.oauth.token.User
   const actorId = user.Account.Actor.id
 
   const resultList = await ActorFollowModel.listSubscriptionsForApi(actorId, req.query.start, req.query.count, req.query.sort)
@@ -147,8 +147,8 @@ async function getUserSubscriptions (req: express.Request, res: express.Response
   return res.json(getFormattedObjects(resultList.data, resultList.total))
 }
 
-async function getUserSubscriptionVideos (req: express.Request, res: express.Response, next: express.NextFunction) {
-  const user = res.locals.oauth.token.User as UserModel
+async function getUserSubscriptionVideos (req: express.Request, res: express.Response) {
+  const user = res.locals.oauth.token.User
   const resultList = await VideoModel.listForApi({
     start: req.query.start,
     count: req.query.count,
diff --git a/server/controllers/api/users/my-video-playlists.ts b/server/controllers/api/users/my-video-playlists.ts
new file mode 100644
index 000000000..15e92f4f3
--- /dev/null
+++ b/server/controllers/api/users/my-video-playlists.ts
@@ -0,0 +1,46 @@
+import * as express from 'express'
+import { asyncMiddleware, authenticate } from '../../../middlewares'
+import { doVideosInPlaylistExistValidator } from '../../../middlewares/validators/videos/video-playlists'
+import { VideoPlaylistModel } from '../../../models/video/video-playlist'
+import { VideoExistInPlaylist } from '../../../../shared/models/videos/playlist/video-exist-in-playlist.model'
+
+const myVideoPlaylistsRouter = express.Router()
+
+myVideoPlaylistsRouter.get('/me/video-playlists/videos-exist',
+  authenticate,
+  doVideosInPlaylistExistValidator,
+  asyncMiddleware(doVideosInPlaylistExist)
+)
+
+// ---------------------------------------------------------------------------
+
+export {
+  myVideoPlaylistsRouter
+}
+
+// ---------------------------------------------------------------------------
+
+async function doVideosInPlaylistExist (req: express.Request, res: express.Response) {
+  const videoIds = req.query.videoIds.map(i => parseInt(i + '', 10))
+  const user = res.locals.oauth.token.User
+
+  const results = await VideoPlaylistModel.listPlaylistIdsOf(user.Account.id, videoIds)
+
+  const existObject: VideoExistInPlaylist = {}
+
+  for (const videoId of videoIds) {
+    existObject[videoId] = []
+  }
+
+  for (const result of results) {
+    for (const element of result.VideoPlaylistElements) {
+      existObject[element.videoId].push({
+        playlistId: result.id,
+        startTimestamp: element.startTimestamp,
+        stopTimestamp: element.stopTimestamp
+      })
+    }
+  }
+
+  return res.json(existObject)
+}
diff --git a/server/controllers/api/video-channel.ts b/server/controllers/api/video-channel.ts
index db7602139..3d6dbfe70 100644
--- a/server/controllers/api/video-channel.ts
+++ b/server/controllers/api/video-channel.ts
@@ -12,7 +12,8 @@ import {
   videoChannelsAddValidator,
   videoChannelsRemoveValidator,
   videoChannelsSortValidator,
-  videoChannelsUpdateValidator
+  videoChannelsUpdateValidator,
+  videoPlaylistsSortValidator
 } from '../../middlewares'
 import { VideoChannelModel } from '../../models/video/video-channel'
 import { videoChannelsNameWithHostValidator, videosSortValidator } from '../../middlewares/validators'
@@ -22,15 +23,18 @@ import { createVideoChannel } from '../../lib/video-channel'
 import { buildNSFWFilter, createReqFiles, isUserAbleToSearchRemoteURI } from '../../helpers/express-utils'
 import { setAsyncActorKeys } from '../../lib/activitypub'
 import { AccountModel } from '../../models/account/account'
-import { CONFIG, MIMETYPES, sequelizeTypescript } from '../../initializers'
+import { MIMETYPES } from '../../initializers/constants'
 import { logger } from '../../helpers/logger'
 import { VideoModel } from '../../models/video/video'
 import { updateAvatarValidator } from '../../middlewares/validators/avatar'
 import { updateActorAvatarFile } from '../../lib/avatar'
 import { auditLoggerFactory, getAuditIdFromRes, VideoChannelAuditView } from '../../helpers/audit-logger'
 import { resetSequelizeInstance } from '../../helpers/database-utils'
-import { UserModel } from '../../models/account/user'
 import { JobQueue } from '../../lib/job-queue'
+import { VideoPlaylistModel } from '../../models/video/video-playlist'
+import { commonVideoPlaylistFiltersValidator } from '../../middlewares/validators/videos/video-playlists'
+import { CONFIG } from '../../initializers/config'
+import { sequelizeTypescript } from '../../initializers/database'
 
 const auditLogger = auditLoggerFactory('channels')
 const reqAvatarFile = createReqFiles([ 'avatarfile' ], MIMETYPES.IMAGE.MIMETYPE_EXT, { avatarfile: CONFIG.STORAGE.TMP_DIR })
@@ -77,6 +81,16 @@ videoChannelRouter.get('/:nameWithHost',
   asyncMiddleware(getVideoChannel)
 )
 
+videoChannelRouter.get('/:nameWithHost/video-playlists',
+  asyncMiddleware(videoChannelsNameWithHostValidator),
+  paginationValidator,
+  videoPlaylistsSortValidator,
+  setDefaultSort,
+  setDefaultPagination,
+  commonVideoPlaylistFiltersValidator,
+  asyncMiddleware(listVideoChannelPlaylists)
+)
+
 videoChannelRouter.get('/:nameWithHost/videos',
   asyncMiddleware(videoChannelsNameWithHostValidator),
   paginationValidator,
@@ -96,16 +110,16 @@ export {
 
 // ---------------------------------------------------------------------------
 
-async function listVideoChannels (req: express.Request, res: express.Response, next: express.NextFunction) {
+async function listVideoChannels (req: express.Request, res: express.Response) {
   const serverActor = await getServerActor()
   const resultList = await VideoChannelModel.listForApi(serverActor.id, req.query.start, req.query.count, req.query.sort)
 
   return res.json(getFormattedObjects(resultList.data, resultList.total))
 }
 
-async function updateVideoChannelAvatar (req: express.Request, res: express.Response, next: express.NextFunction) {
+async function updateVideoChannelAvatar (req: express.Request, res: express.Response) {
   const avatarPhysicalFile = req.files[ 'avatarfile' ][ 0 ]
-  const videoChannel = res.locals.videoChannel as VideoChannelModel
+  const videoChannel = res.locals.videoChannel
   const oldVideoChannelAuditKeys = new VideoChannelAuditView(videoChannel.toFormattedJSON())
 
   const avatar = await updateActorAvatarFile(avatarPhysicalFile, videoChannel)
@@ -123,7 +137,7 @@ async function addVideoChannel (req: express.Request, res: express.Response) {
   const videoChannelInfo: VideoChannelCreate = req.body
 
   const videoChannelCreated: VideoChannelModel = await sequelizeTypescript.transaction(async t => {
-    const account = await AccountModel.load((res.locals.oauth.token.User as UserModel).Account.id, t)
+    const account = await AccountModel.load(res.locals.oauth.token.User.Account.id, t)
 
     return createVideoChannel(videoChannelInfo, account, t)
   })
@@ -143,7 +157,7 @@ async function addVideoChannel (req: express.Request, res: express.Response) {
 }
 
 async function updateVideoChannel (req: express.Request, res: express.Response) {
-  const videoChannelInstance = res.locals.videoChannel as VideoChannelModel
+  const videoChannelInstance = res.locals.videoChannel
   const videoChannelFieldsSave = videoChannelInstance.toJSON()
   const oldVideoChannelAuditKeys = new VideoChannelAuditView(videoChannelInstance.toFormattedJSON())
   const videoChannelInfoToUpdate = req.body as VideoChannelUpdate
@@ -183,9 +197,11 @@ async function updateVideoChannel (req: express.Request, res: express.Response)
 }
 
 async function removeVideoChannel (req: express.Request, res: express.Response) {
-  const videoChannelInstance: VideoChannelModel = res.locals.videoChannel
+  const videoChannelInstance = res.locals.videoChannel
 
   await sequelizeTypescript.transaction(async t => {
+    await VideoPlaylistModel.resetPlaylistsOfChannel(videoChannelInstance.id, t)
+
     await videoChannelInstance.destroy({ transaction: t })
 
     auditLogger.delete(getAuditIdFromRes(res), new VideoChannelAuditView(videoChannelInstance.toFormattedJSON()))
@@ -195,7 +211,7 @@ async function removeVideoChannel (req: express.Request, res: express.Response)
   return res.type('json').status(204).end()
 }
 
-async function getVideoChannel (req: express.Request, res: express.Response, next: express.NextFunction) {
+async function getVideoChannel (req: express.Request, res: express.Response) {
   const videoChannelWithVideos = await VideoChannelModel.loadAndPopulateAccountAndVideos(res.locals.videoChannel.id)
 
   if (videoChannelWithVideos.isOutdated()) {
@@ -206,8 +222,23 @@ async function getVideoChannel (req: express.Request, res: express.Response, nex
   return res.json(videoChannelWithVideos.toFormattedJSON())
 }
 
-async function listVideoChannelVideos (req: express.Request, res: express.Response, next: express.NextFunction) {
-  const videoChannelInstance: VideoChannelModel = res.locals.videoChannel
+async function listVideoChannelPlaylists (req: express.Request, res: express.Response) {
+  const serverActor = await getServerActor()
+
+  const resultList = await VideoPlaylistModel.listForApi({
+    followerActorId: serverActor.id,
+    start: req.query.start,
+    count: req.query.count,
+    sort: req.query.sort,
+    videoChannelId: res.locals.videoChannel.id,
+    type: req.query.playlistType
+  })
+
+  return res.json(getFormattedObjects(resultList.data, resultList.total))
+}
+
+async function listVideoChannelVideos (req: express.Request, res: express.Response) {
+  const videoChannelInstance = res.locals.videoChannel
   const followerActorId = isUserAbleToSearchRemoteURI(res) ? null : undefined
 
   const resultList = await VideoModel.listForApi({
diff --git a/server/controllers/api/video-playlist.ts b/server/controllers/api/video-playlist.ts
new file mode 100644
index 000000000..a17136401
--- /dev/null
+++ b/server/controllers/api/video-playlist.ts
@@ -0,0 +1,445 @@
+import * as express from 'express'
+import { getFormattedObjects, getServerActor } from '../../helpers/utils'
+import {
+  asyncMiddleware,
+  asyncRetryTransactionMiddleware,
+  authenticate,
+  commonVideosFiltersValidator,
+  optionalAuthenticate,
+  paginationValidator,
+  setDefaultPagination,
+  setDefaultSort
+} from '../../middlewares'
+import { videoPlaylistsSortValidator } from '../../middlewares/validators'
+import { buildNSFWFilter, createReqFiles, isUserAbleToSearchRemoteURI } from '../../helpers/express-utils'
+import { MIMETYPES, VIDEO_PLAYLIST_PRIVACIES } from '../../initializers/constants'
+import { logger } from '../../helpers/logger'
+import { resetSequelizeInstance } from '../../helpers/database-utils'
+import { VideoPlaylistModel } from '../../models/video/video-playlist'
+import {
+  commonVideoPlaylistFiltersValidator,
+  videoPlaylistsAddValidator,
+  videoPlaylistsAddVideoValidator,
+  videoPlaylistsDeleteValidator,
+  videoPlaylistsGetValidator,
+  videoPlaylistsReorderVideosValidator,
+  videoPlaylistsUpdateOrRemoveVideoValidator,
+  videoPlaylistsUpdateValidator
+} from '../../middlewares/validators/videos/video-playlists'
+import { VideoPlaylistCreate } from '../../../shared/models/videos/playlist/video-playlist-create.model'
+import { VideoPlaylistPrivacy } from '../../../shared/models/videos/playlist/video-playlist-privacy.model'
+import { join } from 'path'
+import { sendCreateVideoPlaylist, sendDeleteVideoPlaylist, sendUpdateVideoPlaylist } from '../../lib/activitypub/send'
+import { getVideoPlaylistActivityPubUrl, getVideoPlaylistElementActivityPubUrl } from '../../lib/activitypub/url'
+import { VideoPlaylistUpdate } from '../../../shared/models/videos/playlist/video-playlist-update.model'
+import { VideoModel } from '../../models/video/video'
+import { VideoPlaylistElementModel } from '../../models/video/video-playlist-element'
+import { VideoPlaylistElementCreate } from '../../../shared/models/videos/playlist/video-playlist-element-create.model'
+import { VideoPlaylistElementUpdate } from '../../../shared/models/videos/playlist/video-playlist-element-update.model'
+import { AccountModel } from '../../models/account/account'
+import { VideoPlaylistReorder } from '../../../shared/models/videos/playlist/video-playlist-reorder.model'
+import { JobQueue } from '../../lib/job-queue'
+import { CONFIG } from '../../initializers/config'
+import { sequelizeTypescript } from '../../initializers/database'
+import { createPlaylistMiniatureFromExisting } from '../../lib/thumbnail'
+
+const reqThumbnailFile = createReqFiles([ 'thumbnailfile' ], MIMETYPES.IMAGE.MIMETYPE_EXT, { thumbnailfile: CONFIG.STORAGE.TMP_DIR })
+
+const videoPlaylistRouter = express.Router()
+
+videoPlaylistRouter.get('/privacies', listVideoPlaylistPrivacies)
+
+videoPlaylistRouter.get('/',
+  paginationValidator,
+  videoPlaylistsSortValidator,
+  setDefaultSort,
+  setDefaultPagination,
+  commonVideoPlaylistFiltersValidator,
+  asyncMiddleware(listVideoPlaylists)
+)
+
+videoPlaylistRouter.get('/:playlistId',
+  asyncMiddleware(videoPlaylistsGetValidator),
+  getVideoPlaylist
+)
+
+videoPlaylistRouter.post('/',
+  authenticate,
+  reqThumbnailFile,
+  asyncMiddleware(videoPlaylistsAddValidator),
+  asyncRetryTransactionMiddleware(addVideoPlaylist)
+)
+
+videoPlaylistRouter.put('/:playlistId',
+  authenticate,
+  reqThumbnailFile,
+  asyncMiddleware(videoPlaylistsUpdateValidator),
+  asyncRetryTransactionMiddleware(updateVideoPlaylist)
+)
+
+videoPlaylistRouter.delete('/:playlistId',
+  authenticate,
+  asyncMiddleware(videoPlaylistsDeleteValidator),
+  asyncRetryTransactionMiddleware(removeVideoPlaylist)
+)
+
+videoPlaylistRouter.get('/:playlistId/videos',
+  asyncMiddleware(videoPlaylistsGetValidator),
+  paginationValidator,
+  setDefaultPagination,
+  optionalAuthenticate,
+  commonVideosFiltersValidator,
+  asyncMiddleware(getVideoPlaylistVideos)
+)
+
+videoPlaylistRouter.post('/:playlistId/videos',
+  authenticate,
+  asyncMiddleware(videoPlaylistsAddVideoValidator),
+  asyncRetryTransactionMiddleware(addVideoInPlaylist)
+)
+
+videoPlaylistRouter.post('/:playlistId/videos/reorder',
+  authenticate,
+  asyncMiddleware(videoPlaylistsReorderVideosValidator),
+  asyncRetryTransactionMiddleware(reorderVideosPlaylist)
+)
+
+videoPlaylistRouter.put('/:playlistId/videos/:videoId',
+  authenticate,
+  asyncMiddleware(videoPlaylistsUpdateOrRemoveVideoValidator),
+  asyncRetryTransactionMiddleware(updateVideoPlaylistElement)
+)
+
+videoPlaylistRouter.delete('/:playlistId/videos/:videoId',
+  authenticate,
+  asyncMiddleware(videoPlaylistsUpdateOrRemoveVideoValidator),
+  asyncRetryTransactionMiddleware(removeVideoFromPlaylist)
+)
+
+// ---------------------------------------------------------------------------
+
+export {
+  videoPlaylistRouter
+}
+
+// ---------------------------------------------------------------------------
+
+function listVideoPlaylistPrivacies (req: express.Request, res: express.Response) {
+  res.json(VIDEO_PLAYLIST_PRIVACIES)
+}
+
+async function listVideoPlaylists (req: express.Request, res: express.Response) {
+  const serverActor = await getServerActor()
+  const resultList = await VideoPlaylistModel.listForApi({
+    followerActorId: serverActor.id,
+    start: req.query.start,
+    count: req.query.count,
+    sort: req.query.sort,
+    type: req.query.type
+  })
+
+  return res.json(getFormattedObjects(resultList.data, resultList.total))
+}
+
+function getVideoPlaylist (req: express.Request, res: express.Response) {
+  const videoPlaylist = res.locals.videoPlaylist
+
+  if (videoPlaylist.isOutdated()) {
+    JobQueue.Instance.createJob({ type: 'activitypub-refresher', payload: { type: 'video-playlist', url: videoPlaylist.url } })
+            .catch(err => logger.error('Cannot create AP refresher job for playlist %s.', videoPlaylist.url, { err }))
+  }
+
+  return res.json(videoPlaylist.toFormattedJSON())
+}
+
+async function addVideoPlaylist (req: express.Request, res: express.Response) {
+  const videoPlaylistInfo: VideoPlaylistCreate = req.body
+  const user = res.locals.oauth.token.User
+
+  const videoPlaylist = new VideoPlaylistModel({
+    name: videoPlaylistInfo.displayName,
+    description: videoPlaylistInfo.description,
+    privacy: videoPlaylistInfo.privacy || VideoPlaylistPrivacy.PRIVATE,
+    ownerAccountId: user.Account.id
+  })
+
+  videoPlaylist.url = getVideoPlaylistActivityPubUrl(videoPlaylist) // We use the UUID, so set the URL after building the object
+
+  if (videoPlaylistInfo.videoChannelId) {
+    const videoChannel = res.locals.videoChannel
+
+    videoPlaylist.videoChannelId = videoChannel.id
+    videoPlaylist.VideoChannel = videoChannel
+  }
+
+  const thumbnailField = req.files['thumbnailfile']
+  const thumbnailModel = thumbnailField
+    ? await createPlaylistMiniatureFromExisting(thumbnailField[0].path, videoPlaylist)
+    : undefined
+
+  const videoPlaylistCreated: VideoPlaylistModel = await sequelizeTypescript.transaction(async t => {
+    const videoPlaylistCreated = await videoPlaylist.save({ transaction: t })
+
+    if (thumbnailModel) await videoPlaylistCreated.setAndSaveThumbnail(thumbnailModel, t)
+
+    // We need more attributes for the federation
+    videoPlaylistCreated.OwnerAccount = await AccountModel.load(user.Account.id, t)
+    await sendCreateVideoPlaylist(videoPlaylistCreated, t)
+
+    return videoPlaylistCreated
+  })
+
+  logger.info('Video playlist with uuid %s created.', videoPlaylist.uuid)
+
+  return res.json({
+    videoPlaylist: {
+      id: videoPlaylistCreated.id,
+      uuid: videoPlaylistCreated.uuid
+    }
+  }).end()
+}
+
+async function updateVideoPlaylist (req: express.Request, res: express.Response) {
+  const videoPlaylistInstance = res.locals.videoPlaylist
+  const videoPlaylistFieldsSave = videoPlaylistInstance.toJSON()
+  const videoPlaylistInfoToUpdate = req.body as VideoPlaylistUpdate
+  const wasPrivatePlaylist = videoPlaylistInstance.privacy === VideoPlaylistPrivacy.PRIVATE
+
+  const thumbnailField = req.files['thumbnailfile']
+  const thumbnailModel = thumbnailField
+    ? await createPlaylistMiniatureFromExisting(thumbnailField[0].path, videoPlaylistInstance)
+    : undefined
+
+  try {
+    await sequelizeTypescript.transaction(async t => {
+      const sequelizeOptions = {
+        transaction: t
+      }
+
+      if (videoPlaylistInfoToUpdate.videoChannelId !== undefined) {
+        if (videoPlaylistInfoToUpdate.videoChannelId === null) {
+          videoPlaylistInstance.videoChannelId = null
+        } else {
+          const videoChannel = res.locals.videoChannel
+
+          videoPlaylistInstance.videoChannelId = videoChannel.id
+          videoPlaylistInstance.VideoChannel = videoChannel
+        }
+      }
+
+      if (videoPlaylistInfoToUpdate.displayName !== undefined) videoPlaylistInstance.name = videoPlaylistInfoToUpdate.displayName
+      if (videoPlaylistInfoToUpdate.description !== undefined) videoPlaylistInstance.description = videoPlaylistInfoToUpdate.description
+
+      if (videoPlaylistInfoToUpdate.privacy !== undefined) {
+        videoPlaylistInstance.privacy = parseInt(videoPlaylistInfoToUpdate.privacy.toString(), 10)
+      }
+
+      const playlistUpdated = await videoPlaylistInstance.save(sequelizeOptions)
+
+      if (thumbnailModel) await playlistUpdated.setAndSaveThumbnail(thumbnailModel, t)
+
+      const isNewPlaylist = wasPrivatePlaylist && playlistUpdated.privacy !== VideoPlaylistPrivacy.PRIVATE
+
+      if (isNewPlaylist) {
+        await sendCreateVideoPlaylist(playlistUpdated, t)
+      } else {
+        await sendUpdateVideoPlaylist(playlistUpdated, t)
+      }
+
+      logger.info('Video playlist %s updated.', videoPlaylistInstance.uuid)
+
+      return playlistUpdated
+    })
+  } catch (err) {
+    logger.debug('Cannot update the video playlist.', { err })
+
+    // Force fields we want to update
+    // If the transaction is retried, sequelize will think the object has not changed
+    // So it will skip the SQL request, even if the last one was ROLLBACKed!
+    resetSequelizeInstance(videoPlaylistInstance, videoPlaylistFieldsSave)
+
+    throw err
+  }
+
+  return res.type('json').status(204).end()
+}
+
+async function removeVideoPlaylist (req: express.Request, res: express.Response) {
+  const videoPlaylistInstance = res.locals.videoPlaylist
+
+  await sequelizeTypescript.transaction(async t => {
+    await videoPlaylistInstance.destroy({ transaction: t })
+
+    await sendDeleteVideoPlaylist(videoPlaylistInstance, t)
+
+    logger.info('Video playlist %s deleted.', videoPlaylistInstance.uuid)
+  })
+
+  return res.type('json').status(204).end()
+}
+
+async function addVideoInPlaylist (req: express.Request, res: express.Response) {
+  const body: VideoPlaylistElementCreate = req.body
+  const videoPlaylist = res.locals.videoPlaylist
+  const video = res.locals.video
+
+  const playlistElement: VideoPlaylistElementModel = await sequelizeTypescript.transaction(async t => {
+    const position = await VideoPlaylistElementModel.getNextPositionOf(videoPlaylist.id, t)
+
+    const playlistElement = await VideoPlaylistElementModel.create({
+      url: getVideoPlaylistElementActivityPubUrl(videoPlaylist, video),
+      position,
+      startTimestamp: body.startTimestamp || null,
+      stopTimestamp: body.stopTimestamp || null,
+      videoPlaylistId: videoPlaylist.id,
+      videoId: video.id
+    }, { transaction: t })
+
+    videoPlaylist.changed('updatedAt', true)
+    await videoPlaylist.save({ transaction: t })
+
+    await sendUpdateVideoPlaylist(videoPlaylist, t)
+
+    return playlistElement
+  })
+
+  // If the user did not set a thumbnail, automatically take the video thumbnail
+  if (videoPlaylist.hasThumbnail() === false) {
+    logger.info('Generating default thumbnail to playlist %s.', videoPlaylist.url)
+
+    const inputPath = join(CONFIG.STORAGE.THUMBNAILS_DIR, video.getMiniature().filename)
+    const thumbnailModel = await createPlaylistMiniatureFromExisting(inputPath, videoPlaylist, true)
+
+    thumbnailModel.videoPlaylistId = videoPlaylist.id
+
+    await thumbnailModel.save()
+  }
+
+  logger.info('Video added in playlist %s at position %d.', videoPlaylist.uuid, playlistElement.position)
+
+  return res.json({
+    videoPlaylistElement: {
+      id: playlistElement.id
+    }
+  }).end()
+}
+
+async function updateVideoPlaylistElement (req: express.Request, res: express.Response) {
+  const body: VideoPlaylistElementUpdate = req.body
+  const videoPlaylist = res.locals.videoPlaylist
+  const videoPlaylistElement = res.locals.videoPlaylistElement
+
+  const playlistElement: VideoPlaylistElementModel = await sequelizeTypescript.transaction(async t => {
+    if (body.startTimestamp !== undefined) videoPlaylistElement.startTimestamp = body.startTimestamp
+    if (body.stopTimestamp !== undefined) videoPlaylistElement.stopTimestamp = body.stopTimestamp
+
+    const element = await videoPlaylistElement.save({ transaction: t })
+
+    videoPlaylist.changed('updatedAt', true)
+    await videoPlaylist.save({ transaction: t })
+
+    await sendUpdateVideoPlaylist(videoPlaylist, t)
+
+    return element
+  })
+
+  logger.info('Element of position %d of playlist %s updated.', playlistElement.position, videoPlaylist.uuid)
+
+  return res.type('json').status(204).end()
+}
+
+async function removeVideoFromPlaylist (req: express.Request, res: express.Response) {
+  const videoPlaylistElement = res.locals.videoPlaylistElement
+  const videoPlaylist = res.locals.videoPlaylist
+  const positionToDelete = videoPlaylistElement.position
+
+  await sequelizeTypescript.transaction(async t => {
+    await videoPlaylistElement.destroy({ transaction: t })
+
+    // Decrease position of the next elements
+    await VideoPlaylistElementModel.increasePositionOf(videoPlaylist.id, positionToDelete, null, -1, t)
+
+    videoPlaylist.changed('updatedAt', true)
+    await videoPlaylist.save({ transaction: t })
+
+    await sendUpdateVideoPlaylist(videoPlaylist, t)
+
+    logger.info('Video playlist element %d of playlist %s deleted.', videoPlaylistElement.position, videoPlaylist.uuid)
+  })
+
+  return res.type('json').status(204).end()
+}
+
+async function reorderVideosPlaylist (req: express.Request, res: express.Response) {
+  const videoPlaylist = res.locals.videoPlaylist
+  const body: VideoPlaylistReorder = req.body
+
+  const start: number = body.startPosition
+  const insertAfter: number = body.insertAfterPosition
+  const reorderLength: number = body.reorderLength || 1
+
+  if (start === insertAfter) {
+    return res.status(204).end()
+  }
+
+  // Example: if we reorder position 2 and insert after position 5 (so at position 6): # 1 2 3 4 5 6 7 8 9
+  //  * increase position when position > 5 # 1 2 3 4 5 7 8 9 10
+  //  * update position 2 -> position 6 # 1 3 4 5 6 7 8 9 10
+  //  * decrease position when position position > 2 # 1 2 3 4 5 6 7 8 9
+  await sequelizeTypescript.transaction(async t => {
+    const newPosition = insertAfter + 1
+
+    // Add space after the position when we want to insert our reordered elements (increase)
+    await VideoPlaylistElementModel.increasePositionOf(videoPlaylist.id, newPosition, null, reorderLength, t)
+
+    let oldPosition = start
+
+    // We incremented the position of the elements we want to reorder
+    if (start >= newPosition) oldPosition += reorderLength
+
+    const endOldPosition = oldPosition + reorderLength - 1
+    // Insert our reordered elements in their place (update)
+    await VideoPlaylistElementModel.reassignPositionOf(videoPlaylist.id, oldPosition, endOldPosition, newPosition, t)
+
+    // Decrease positions of elements after the old position of our ordered elements (decrease)
+    await VideoPlaylistElementModel.increasePositionOf(videoPlaylist.id, oldPosition, null, -reorderLength, t)
+
+    videoPlaylist.changed('updatedAt', true)
+    await videoPlaylist.save({ transaction: t })
+
+    await sendUpdateVideoPlaylist(videoPlaylist, t)
+  })
+
+  logger.info(
+    'Reordered playlist %s (inserted after %d elements %d - %d).',
+    videoPlaylist.uuid, insertAfter, start, start + reorderLength - 1
+  )
+
+  return res.type('json').status(204).end()
+}
+
+async function getVideoPlaylistVideos (req: express.Request, res: express.Response) {
+  const videoPlaylistInstance = res.locals.videoPlaylist
+  const followerActorId = isUserAbleToSearchRemoteURI(res) ? null : undefined
+
+  const resultList = await VideoModel.listForApi({
+    followerActorId,
+    start: req.query.start,
+    count: req.query.count,
+    sort: 'VideoPlaylistElements.position',
+    includeLocalVideos: true,
+    categoryOneOf: req.query.categoryOneOf,
+    licenceOneOf: req.query.licenceOneOf,
+    languageOneOf: req.query.languageOneOf,
+    tagsOneOf: req.query.tagsOneOf,
+    tagsAllOf: req.query.tagsAllOf,
+    filter: req.query.filter,
+    nsfw: buildNSFWFilter(res, req.query.nsfw),
+    withFiles: false,
+    videoPlaylistId: videoPlaylistInstance.id,
+    user: res.locals.oauth ? res.locals.oauth.token.User : undefined
+  })
+
+  const additionalAttributes = { playlistInfo: true }
+  return res.json(getFormattedObjects(resultList.data, resultList.total, { additionalAttributes }))
+}
diff --git a/server/controllers/api/videos/abuse.ts b/server/controllers/api/videos/abuse.ts
index fe0a95cd5..ca70230a2 100644
--- a/server/controllers/api/videos/abuse.ts
+++ b/server/controllers/api/videos/abuse.ts
@@ -3,7 +3,6 @@ import { UserRight, VideoAbuseCreate, VideoAbuseState } from '../../../../shared
 import { logger } from '../../../helpers/logger'
 import { getFormattedObjects } from '../../../helpers/utils'
 import { sequelizeTypescript } from '../../../initializers'
-import { sendVideoAbuse } from '../../../lib/activitypub/send'
 import {
   asyncMiddleware,
   asyncRetryTransactionMiddleware,
@@ -18,11 +17,10 @@ import {
   videoAbuseUpdateValidator
 } from '../../../middlewares'
 import { AccountModel } from '../../../models/account/account'
-import { VideoModel } from '../../../models/video/video'
 import { VideoAbuseModel } from '../../../models/video/video-abuse'
 import { auditLoggerFactory, VideoAbuseAuditView } from '../../../helpers/audit-logger'
-import { UserModel } from '../../../models/account/user'
 import { Notifier } from '../../../lib/notifier'
+import { sendVideoAbuse } from '../../../lib/activitypub/send/send-flag'
 
 const auditLogger = auditLoggerFactory('abuse')
 const abuseVideoRouter = express.Router()
@@ -69,7 +67,7 @@ async function listVideoAbuses (req: express.Request, res: express.Response) {
 }
 
 async function updateVideoAbuse (req: express.Request, res: express.Response) {
-  const videoAbuse: VideoAbuseModel = res.locals.videoAbuse
+  const videoAbuse = res.locals.videoAbuse
 
   if (req.body.moderationComment !== undefined) videoAbuse.moderationComment = req.body.moderationComment
   if (req.body.state !== undefined) videoAbuse.state = req.body.state
@@ -84,7 +82,7 @@ async function updateVideoAbuse (req: express.Request, res: express.Response) {
 }
 
 async function deleteVideoAbuse (req: express.Request, res: express.Response) {
-  const videoAbuse: VideoAbuseModel = res.locals.videoAbuse
+  const videoAbuse = res.locals.videoAbuse
 
   await sequelizeTypescript.transaction(t => {
     return videoAbuse.destroy({ transaction: t })
@@ -96,11 +94,11 @@ async function deleteVideoAbuse (req: express.Request, res: express.Response) {
 }
 
 async function reportVideoAbuse (req: express.Request, res: express.Response) {
-  const videoInstance = res.locals.video as VideoModel
+  const videoInstance = res.locals.video
   const body: VideoAbuseCreate = req.body
 
   const videoAbuse: VideoAbuseModel = await sequelizeTypescript.transaction(async t => {
-    const reporterAccount = await AccountModel.load((res.locals.oauth.token.User as UserModel).Account.id, t)
+    const reporterAccount = await AccountModel.load(res.locals.oauth.token.User.Account.id, t)
 
     const abuseToCreate = {
       reporterAccountId: reporterAccount.id,
diff --git a/server/controllers/api/videos/blacklist.ts b/server/controllers/api/videos/blacklist.ts
index 43b0516e7..27dcfb761 100644
--- a/server/controllers/api/videos/blacklist.ts
+++ b/server/controllers/api/videos/blacklist.ts
@@ -1,5 +1,5 @@
 import * as express from 'express'
-import { VideoBlacklist, UserRight, VideoBlacklistCreate } from '../../../../shared'
+import { VideoBlacklist, UserRight, VideoBlacklistCreate, VideoBlacklistType } from '../../../../shared'
 import { logger } from '../../../helpers/logger'
 import { getFormattedObjects } from '../../../helpers/utils'
 import {
@@ -12,13 +12,13 @@ import {
   setDefaultPagination,
   videosBlacklistAddValidator,
   videosBlacklistRemoveValidator,
-  videosBlacklistUpdateValidator
+  videosBlacklistUpdateValidator,
+  videosBlacklistFiltersValidator
 } from '../../../middlewares'
 import { VideoBlacklistModel } from '../../../models/video/video-blacklist'
 import { sequelizeTypescript } from '../../../initializers'
 import { Notifier } from '../../../lib/notifier'
-import { VideoModel } from '../../../models/video/video'
-import { sendCreateVideo, sendDeleteVideo, sendUpdateVideo } from '../../../lib/activitypub/send'
+import { sendDeleteVideo } from '../../../lib/activitypub/send'
 import { federateVideoIfNeeded } from '../../../lib/activitypub'
 
 const blacklistRouter = express.Router()
@@ -37,6 +37,7 @@ blacklistRouter.get('/blacklist',
   blacklistSortValidator,
   setBlacklistSort,
   setDefaultPagination,
+  videosBlacklistFiltersValidator,
   asyncMiddleware(listBlacklist)
 )
 
@@ -69,7 +70,8 @@ async function addVideoToBlacklist (req: express.Request, res: express.Response)
   const toCreate = {
     videoId: videoInstance.id,
     unfederated: body.unfederate === true,
-    reason: body.reason
+    reason: body.reason,
+    type: VideoBlacklistType.MANUAL
   }
 
   const blacklist = await VideoBlacklistModel.create(toCreate)
@@ -87,7 +89,7 @@ async function addVideoToBlacklist (req: express.Request, res: express.Response)
 }
 
 async function updateVideoBlacklistController (req: express.Request, res: express.Response) {
-  const videoBlacklist = res.locals.videoBlacklist as VideoBlacklistModel
+  const videoBlacklist = res.locals.videoBlacklist
 
   if (req.body.reason !== undefined) videoBlacklist.reason = req.body.reason
 
@@ -99,27 +101,39 @@ async function updateVideoBlacklistController (req: express.Request, res: expres
 }
 
 async function listBlacklist (req: express.Request, res: express.Response, next: express.NextFunction) {
-  const resultList = await VideoBlacklistModel.listForApi(req.query.start, req.query.count, req.query.sort)
+  const resultList = await VideoBlacklistModel.listForApi(req.query.start, req.query.count, req.query.sort, req.query.type)
 
   return res.json(getFormattedObjects<VideoBlacklist, VideoBlacklistModel>(resultList.data, resultList.total))
 }
 
 async function removeVideoFromBlacklistController (req: express.Request, res: express.Response, next: express.NextFunction) {
-  const videoBlacklist = res.locals.videoBlacklist as VideoBlacklistModel
-  const video: VideoModel = res.locals.video
+  const videoBlacklist = res.locals.videoBlacklist
+  const video = res.locals.video
 
-  await sequelizeTypescript.transaction(async t => {
+  const videoBlacklistType = await sequelizeTypescript.transaction(async t => {
     const unfederated = videoBlacklist.unfederated
+    const videoBlacklistType = videoBlacklist.type
+
     await videoBlacklist.destroy({ transaction: t })
 
     // Re federate the video
     if (unfederated === true) {
       await federateVideoIfNeeded(video, true, t)
     }
+
+    return videoBlacklistType
   })
 
   Notifier.Instance.notifyOnVideoUnblacklist(video)
 
+  if (videoBlacklistType === VideoBlacklistType.AUTO_BEFORE_PUBLISHED) {
+    Notifier.Instance.notifyOnVideoPublishedAfterRemovedFromAutoBlacklist(video)
+
+    // Delete on object so new video notifications will send
+    delete video.VideoBlacklist
+    Notifier.Instance.notifyOnNewVideo(video)
+  }
+
   logger.info('Video %s removed from blacklist.', res.locals.video.uuid)
 
   return res.type('json').status(204).end()
diff --git a/server/controllers/api/videos/captions.ts b/server/controllers/api/videos/captions.ts
index 9b3661368..44c255232 100644
--- a/server/controllers/api/videos/captions.ts
+++ b/server/controllers/api/videos/captions.ts
@@ -2,13 +2,14 @@ import * as express from 'express'
 import { asyncMiddleware, asyncRetryTransactionMiddleware, authenticate } from '../../../middlewares'
 import { addVideoCaptionValidator, deleteVideoCaptionValidator, listVideoCaptionsValidator } from '../../../middlewares/validators'
 import { createReqFiles } from '../../../helpers/express-utils'
-import { CONFIG, MIMETYPES, sequelizeTypescript } from '../../../initializers'
+import { MIMETYPES } from '../../../initializers/constants'
 import { getFormattedObjects } from '../../../helpers/utils'
 import { VideoCaptionModel } from '../../../models/video/video-caption'
-import { VideoModel } from '../../../models/video/video'
 import { logger } from '../../../helpers/logger'
 import { federateVideoIfNeeded } from '../../../lib/activitypub'
 import { moveAndProcessCaptionFile } from '../../../helpers/captions-utils'
+import { CONFIG } from '../../../initializers/config'
+import { sequelizeTypescript } from '../../../initializers/database'
 
 const reqVideoCaptionAdd = createReqFiles(
   [ 'captionfile' ],
@@ -52,7 +53,7 @@ async function listVideoCaptions (req: express.Request, res: express.Response) {
 
 async function addVideoCaption (req: express.Request, res: express.Response) {
   const videoCaptionPhysicalFile = req.files['captionfile'][0]
-  const video = res.locals.video as VideoModel
+  const video = res.locals.video
 
   const videoCaption = new VideoCaptionModel({
     videoId: video.id,
@@ -74,8 +75,8 @@ async function addVideoCaption (req: express.Request, res: express.Response) {
 }
 
 async function deleteVideoCaption (req: express.Request, res: express.Response) {
-  const video = res.locals.video as VideoModel
-  const videoCaption = res.locals.videoCaption as VideoCaptionModel
+  const video = res.locals.video
+  const videoCaption = res.locals.videoCaption
 
   await sequelizeTypescript.transaction(async t => {
     await videoCaption.destroy({ transaction: t })
diff --git a/server/controllers/api/videos/comment.ts b/server/controllers/api/videos/comment.ts
index 70c1148ba..176ee8bd4 100644
--- a/server/controllers/api/videos/comment.ts
+++ b/server/controllers/api/videos/comment.ts
@@ -8,7 +8,8 @@ import { buildFormattedCommentTree, createVideoComment } from '../../../lib/vide
 import {
   asyncMiddleware,
   asyncRetryTransactionMiddleware,
-  authenticate, optionalAuthenticate,
+  authenticate,
+  optionalAuthenticate,
   paginationValidator,
   setDefaultPagination,
   setDefaultSort
@@ -21,11 +22,9 @@ import {
   removeVideoCommentValidator,
   videoCommentThreadsSortValidator
 } from '../../../middlewares/validators'
-import { VideoModel } from '../../../models/video/video'
 import { VideoCommentModel } from '../../../models/video/video-comment'
 import { auditLoggerFactory, CommentAuditView, getAuditIdFromRes } from '../../../helpers/audit-logger'
 import { AccountModel } from '../../../models/account/account'
-import { UserModel } from '../../../models/account/user'
 import { Notifier } from '../../../lib/notifier'
 
 const auditLogger = auditLoggerFactory('comments')
@@ -70,9 +69,9 @@ export {
 
 // ---------------------------------------------------------------------------
 
-async function listVideoThreads (req: express.Request, res: express.Response, next: express.NextFunction) {
-  const video = res.locals.video as VideoModel
-  const user: UserModel = res.locals.oauth ? res.locals.oauth.token.User : undefined
+async function listVideoThreads (req: express.Request, res: express.Response) {
+  const video = res.locals.video
+  const user = res.locals.oauth ? res.locals.oauth.token.User : undefined
 
   let resultList: ResultList<VideoCommentModel>
 
@@ -88,9 +87,9 @@ async function listVideoThreads (req: express.Request, res: express.Response, ne
   return res.json(getFormattedObjects(resultList.data, resultList.total))
 }
 
-async function listVideoThreadComments (req: express.Request, res: express.Response, next: express.NextFunction) {
-  const video = res.locals.video as VideoModel
-  const user: UserModel = res.locals.oauth ? res.locals.oauth.token.User : undefined
+async function listVideoThreadComments (req: express.Request, res: express.Response) {
+  const video = res.locals.video
+  const user = res.locals.oauth ? res.locals.oauth.token.User : undefined
 
   let resultList: ResultList<VideoCommentModel>
 
@@ -110,7 +109,7 @@ async function addVideoCommentThread (req: express.Request, res: express.Respons
   const videoCommentInfo: VideoCommentCreate = req.body
 
   const comment = await sequelizeTypescript.transaction(async t => {
-    const account = await AccountModel.load((res.locals.oauth.token.User as UserModel).Account.id, t)
+    const account = await AccountModel.load(res.locals.oauth.token.User.Account.id, t)
 
     return createVideoComment({
       text: videoCommentInfo.text,
@@ -132,7 +131,7 @@ async function addVideoCommentReply (req: express.Request, res: express.Response
   const videoCommentInfo: VideoCommentCreate = req.body
 
   const comment = await sequelizeTypescript.transaction(async t => {
-    const account = await AccountModel.load((res.locals.oauth.token.User as UserModel).Account.id, t)
+    const account = await AccountModel.load(res.locals.oauth.token.User.Account.id, t)
 
     return createVideoComment({
       text: videoCommentInfo.text,
@@ -149,7 +148,7 @@ async function addVideoCommentReply (req: express.Request, res: express.Response
 }
 
 async function removeVideoComment (req: express.Request, res: express.Response) {
-  const videoCommentInstance: VideoCommentModel = res.locals.videoComment
+  const videoCommentInstance = res.locals.videoComment
 
   await sequelizeTypescript.transaction(async t => {
     await videoCommentInstance.destroy({ transaction: t })
diff --git a/server/controllers/api/videos/import.ts b/server/controllers/api/videos/import.ts
index 98366cd82..bfb690906 100644
--- a/server/controllers/api/videos/import.ts
+++ b/server/controllers/api/videos/import.ts
@@ -3,7 +3,7 @@ import * as magnetUtil from 'magnet-uri'
 import 'multer'
 import { auditLoggerFactory, getAuditIdFromRes, VideoImportAuditView } from '../../../helpers/audit-logger'
 import { asyncMiddleware, asyncRetryTransactionMiddleware, authenticate, videoImportAddValidator } from '../../../middlewares'
-import { CONFIG, MIMETYPES, PREVIEWS_SIZE, sequelizeTypescript, THUMBNAILS_SIZE } from '../../../initializers'
+import { MIMETYPES } from '../../../initializers/constants'
 import { getYoutubeDLInfo, YoutubeDLInfo } from '../../../helpers/youtube-dl'
 import { createReqFiles } from '../../../helpers/express-utils'
 import { logger } from '../../../helpers/logger'
@@ -13,15 +13,19 @@ import { getVideoActivityPubUrl } from '../../../lib/activitypub'
 import { TagModel } from '../../../models/video/tag'
 import { VideoImportModel } from '../../../models/video/video-import'
 import { JobQueue } from '../../../lib/job-queue/job-queue'
-import { processImage } from '../../../helpers/image-utils'
 import { join } from 'path'
 import { isArray } from '../../../helpers/custom-validators/misc'
-import { FilteredModelAttributes } from 'sequelize-typescript/lib/models/Model'
 import { VideoChannelModel } from '../../../models/video/video-channel'
 import * as Bluebird from 'bluebird'
 import * as parseTorrent from 'parse-torrent'
 import { getSecureTorrentName } from '../../../helpers/utils'
-import { readFile, move } from 'fs-extra'
+import { move, readFile } from 'fs-extra'
+import { autoBlacklistVideoIfNeeded } from '../../../lib/video-blacklist'
+import { CONFIG } from '../../../initializers/config'
+import { sequelizeTypescript } from '../../../initializers/database'
+import { createVideoMiniatureFromExisting } from '../../../lib/thumbnail'
+import { ThumbnailType } from '../../../../shared/models/videos/thumbnail.type'
+import { ThumbnailModel } from '../../../models/video/thumbnail'
 
 const auditLogger = auditLoggerFactory('video-imports')
 const videoImportsRouter = express.Router()
@@ -87,8 +91,8 @@ async function addTorrentImport (req: express.Request, res: express.Response, to
 
   const video = buildVideo(res.locals.videoChannel.id, body, { name: videoName })
 
-  await processThumbnail(req, video)
-  await processPreview(req, video)
+  const thumbnailModel = await processThumbnail(req, video)
+  const previewModel = await processPreview(req, video)
 
   const tags = body.tags || undefined
   const videoImportAttributes = {
@@ -97,7 +101,14 @@ async function addTorrentImport (req: express.Request, res: express.Response, to
     state: VideoImportState.PENDING,
     userId: user.id
   }
-  const videoImport: VideoImportModel = await insertIntoDB(video, res.locals.videoChannel, tags, videoImportAttributes)
+  const videoImport = await insertIntoDB({
+    video,
+    thumbnailModel,
+    previewModel,
+    videoChannel: res.locals.videoChannel,
+    tags,
+    videoImportAttributes
+  })
 
   // Create job to import the video
   const payload = {
@@ -130,8 +141,8 @@ async function addYoutubeDLImport (req: express.Request, res: express.Response)
 
   const video = buildVideo(res.locals.videoChannel.id, body, youtubeDLInfo)
 
-  const downloadThumbnail = !await processThumbnail(req, video)
-  const downloadPreview = !await processPreview(req, video)
+  const thumbnailModel = await processThumbnail(req, video)
+  const previewModel = await processPreview(req, video)
 
   const tags = body.tags || youtubeDLInfo.tags
   const videoImportAttributes = {
@@ -139,15 +150,22 @@ async function addYoutubeDLImport (req: express.Request, res: express.Response)
     state: VideoImportState.PENDING,
     userId: user.id
   }
-  const videoImport: VideoImportModel = await insertIntoDB(video, res.locals.videoChannel, tags, videoImportAttributes)
+  const videoImport = await insertIntoDB({
+    video: video,
+    thumbnailModel,
+    previewModel,
+    videoChannel: res.locals.videoChannel,
+    tags,
+    videoImportAttributes
+  })
 
   // Create job to import the video
   const payload = {
     type: 'youtube-dl' as 'youtube-dl',
     videoImportId: videoImport.id,
     thumbnailUrl: youtubeDLInfo.thumbnailUrl,
-    downloadThumbnail,
-    downloadPreview
+    downloadThumbnail: !thumbnailModel,
+    downloadPreview: !previewModel
   }
   await JobQueue.Instance.createJob({ type: 'video-import', payload })
 
@@ -164,6 +182,7 @@ function buildVideo (channelId: number, body: VideoImportCreate, importData: You
     licence: body.licence || importData.licence,
     language: body.language || undefined,
     commentsEnabled: body.commentsEnabled || true,
+    downloadEnabled: body.downloadEnabled || true,
     waitTranscoding: body.waitTranscoding || false,
     state: VideoState.TO_IMPORT,
     nsfw: body.nsfw || importData.nsfw || false,
@@ -171,7 +190,8 @@ function buildVideo (channelId: number, body: VideoImportCreate, importData: You
     support: body.support || null,
     privacy: body.privacy || VideoPrivacy.PRIVATE,
     duration: 0, // duration will be set by the import job
-    channelId: channelId
+    channelId: channelId,
+    originallyPublishedAt: importData.originallyPublishedAt
   }
   const video = new VideoModel(videoData)
   video.url = getVideoActivityPubUrl(video)
@@ -183,32 +203,34 @@ async function processThumbnail (req: express.Request, video: VideoModel) {
   const thumbnailField = req.files ? req.files['thumbnailfile'] : undefined
   if (thumbnailField) {
     const thumbnailPhysicalFile = thumbnailField[ 0 ]
-    await processImage(thumbnailPhysicalFile, join(CONFIG.STORAGE.THUMBNAILS_DIR, video.getThumbnailName()), THUMBNAILS_SIZE)
 
-    return true
+    return createVideoMiniatureFromExisting(thumbnailPhysicalFile.path, video, ThumbnailType.MINIATURE)
   }
 
-  return false
+  return undefined
 }
 
 async function processPreview (req: express.Request, video: VideoModel) {
   const previewField = req.files ? req.files['previewfile'] : undefined
   if (previewField) {
     const previewPhysicalFile = previewField[0]
-    await processImage(previewPhysicalFile, join(CONFIG.STORAGE.PREVIEWS_DIR, video.getPreviewName()), PREVIEWS_SIZE)
 
-    return true
+    return createVideoMiniatureFromExisting(previewPhysicalFile.path, video, ThumbnailType.PREVIEW)
   }
 
-  return false
+  return undefined
 }
 
-function insertIntoDB (
+function insertIntoDB (parameters: {
   video: VideoModel,
+  thumbnailModel: ThumbnailModel,
+  previewModel: ThumbnailModel,
   videoChannel: VideoChannelModel,
   tags: string[],
-  videoImportAttributes: FilteredModelAttributes<VideoImportModel>
-): Bluebird<VideoImportModel> {
+  videoImportAttributes: Partial<VideoImportModel>
+}): Bluebird<VideoImportModel> {
+  let { video, thumbnailModel, previewModel, videoChannel, tags, videoImportAttributes } = parameters
+
   return sequelizeTypescript.transaction(async t => {
     const sequelizeOptions = { transaction: t }
 
@@ -216,6 +238,11 @@ function insertIntoDB (
     const videoCreated = await video.save(sequelizeOptions)
     videoCreated.VideoChannel = videoChannel
 
+    if (thumbnailModel) await videoCreated.addAndSaveThumbnail(thumbnailModel, t)
+    if (previewModel) await videoCreated.addAndSaveThumbnail(previewModel, t)
+
+    await autoBlacklistVideoIfNeeded(video, videoChannel.Account.User, t)
+
     // Set tags to the video
     if (tags) {
       const tagInstances = await TagModel.findOrCreateTags(tags, t)
diff --git a/server/controllers/api/videos/index.ts b/server/controllers/api/videos/index.ts
index 2b2dfa7ca..1a18a8ae8 100644
--- a/server/controllers/api/videos/index.ts
+++ b/server/controllers/api/videos/index.ts
@@ -2,28 +2,17 @@ import * as express from 'express'
 import { extname, join } from 'path'
 import { VideoCreate, VideoPrivacy, VideoState, VideoUpdate } from '../../../../shared'
 import { getVideoFileFPS, getVideoFileResolution } from '../../../helpers/ffmpeg-utils'
-import { processImage } from '../../../helpers/image-utils'
 import { logger } from '../../../helpers/logger'
 import { auditLoggerFactory, getAuditIdFromRes, VideoAuditView } from '../../../helpers/audit-logger'
 import { getFormattedObjects, getServerActor } from '../../../helpers/utils'
-import {
-  CONFIG,
-  MIMETYPES,
-  PREVIEWS_SIZE,
-  sequelizeTypescript,
-  THUMBNAILS_SIZE,
-  VIDEO_CATEGORIES,
-  VIDEO_LANGUAGES,
-  VIDEO_LICENCES,
-  VIDEO_PRIVACIES
-} from '../../../initializers'
+import { autoBlacklistVideoIfNeeded } from '../../../lib/video-blacklist'
+import { MIMETYPES, VIDEO_CATEGORIES, VIDEO_LANGUAGES, VIDEO_LICENCES, VIDEO_PRIVACIES } from '../../../initializers/constants'
 import {
   changeVideoChannelShare,
   federateVideoIfNeeded,
   fetchRemoteVideoDescription,
   getVideoActivityPubUrl
 } from '../../../lib/activitypub'
-import { sendCreateView } from '../../../lib/activitypub/send'
 import { JobQueue } from '../../../lib/job-queue'
 import { Redis } from '../../../lib/redis'
 import {
@@ -37,6 +26,7 @@ import {
   setDefaultPagination,
   setDefaultSort,
   videosAddValidator,
+  videosCustomGetValidator,
   videosGetValidator,
   videosRemoveValidator,
   videosSortValidator,
@@ -59,6 +49,11 @@ import { resetSequelizeInstance } from '../../../helpers/database-utils'
 import { move } from 'fs-extra'
 import { watchingRouter } from './watching'
 import { Notifier } from '../../../lib/notifier'
+import { sendView } from '../../../lib/activitypub/send/send-view'
+import { CONFIG } from '../../../initializers/config'
+import { sequelizeTypescript } from '../../../initializers/database'
+import { createVideoMiniatureFromExisting, generateVideoMiniature } from '../../../lib/thumbnail'
+import { ThumbnailType } from '../../../../shared/models/videos/thumbnail.type'
 
 const auditLogger = auditLoggerFactory('videos')
 const videosRouter = express.Router()
@@ -123,9 +118,9 @@ videosRouter.get('/:id/description',
 )
 videosRouter.get('/:id',
   optionalAuthenticate,
-  asyncMiddleware(videosGetValidator),
+  asyncMiddleware(videosCustomGetValidator('only-video-with-rights')),
   asyncMiddleware(checkVideoFollowConstraints),
-  getVideo
+  asyncMiddleware(getVideo)
 )
 videosRouter.post('/:id/views',
   asyncMiddleware(videosGetValidator),
@@ -181,15 +176,18 @@ async function addVideo (req: express.Request, res: express.Response) {
     licence: videoInfo.licence,
     language: videoInfo.language,
     commentsEnabled: videoInfo.commentsEnabled || false,
+    downloadEnabled: videoInfo.downloadEnabled || true,
     waitTranscoding: videoInfo.waitTranscoding || false,
     state: CONFIG.TRANSCODING.ENABLED ? VideoState.TO_TRANSCODE : VideoState.PUBLISHED,
     nsfw: videoInfo.nsfw || false,
     description: videoInfo.description,
     support: videoInfo.support,
-    privacy: videoInfo.privacy,
+    privacy: videoInfo.privacy || VideoPrivacy.PRIVATE,
     duration: videoPhysicalFile['duration'], // duration was added by a previous middleware
-    channelId: res.locals.videoChannel.id
+    channelId: res.locals.videoChannel.id,
+    originallyPublishedAt: videoInfo.originallyPublishedAt
   }
+
   const video = new VideoModel(videoData)
   video.url = getVideoActivityPubUrl(video) // We use the UUID, so set the URL after building the object
 
@@ -215,29 +213,27 @@ async function addVideo (req: express.Request, res: express.Response) {
 
   // Process thumbnail or create it from the video
   const thumbnailField = req.files['thumbnailfile']
-  if (thumbnailField) {
-    const thumbnailPhysicalFile = thumbnailField[0]
-    await processImage(thumbnailPhysicalFile, join(CONFIG.STORAGE.THUMBNAILS_DIR, video.getThumbnailName()), THUMBNAILS_SIZE)
-  } else {
-    await video.createThumbnail(videoFile)
-  }
+  const thumbnailModel = thumbnailField
+    ? await createVideoMiniatureFromExisting(thumbnailField[0].path, video, ThumbnailType.MINIATURE)
+    : await generateVideoMiniature(video, videoFile, ThumbnailType.MINIATURE)
 
   // Process preview or create it from the video
   const previewField = req.files['previewfile']
-  if (previewField) {
-    const previewPhysicalFile = previewField[0]
-    await processImage(previewPhysicalFile, join(CONFIG.STORAGE.PREVIEWS_DIR, video.getPreviewName()), PREVIEWS_SIZE)
-  } else {
-    await video.createPreview(videoFile)
-  }
+  const previewModel = previewField
+    ? await createVideoMiniatureFromExisting(previewField[0].path, video, ThumbnailType.PREVIEW)
+    : await generateVideoMiniature(video, videoFile, ThumbnailType.PREVIEW)
 
   // Create the torrent file
   await video.createTorrentAndSetInfoHash(videoFile)
 
-  const videoCreated = await sequelizeTypescript.transaction(async t => {
+  const { videoCreated, videoWasAutoBlacklisted } = await sequelizeTypescript.transaction(async t => {
     const sequelizeOptions = { transaction: t }
 
     const videoCreated = await video.save(sequelizeOptions)
+
+    await videoCreated.addAndSaveThumbnail(thumbnailModel, t)
+    await videoCreated.addAndSaveThumbnail(previewModel, t)
+
     // Do not forget to add video channel information to the created video
     videoCreated.VideoChannel = res.locals.videoChannel
 
@@ -263,15 +259,23 @@ async function addVideo (req: express.Request, res: express.Response) {
       }, { transaction: t })
     }
 
-    await federateVideoIfNeeded(video, true, t)
+    const videoWasAutoBlacklisted = await autoBlacklistVideoIfNeeded(video, res.locals.oauth.token.User, t)
+
+    if (!videoWasAutoBlacklisted) {
+      await federateVideoIfNeeded(video, true, t)
+    }
 
     auditLogger.create(getAuditIdFromRes(res), new VideoAuditView(videoCreated.toFormattedDetailsJSON()))
     logger.info('Video with name %s and uuid %s created.', videoInfo.name, videoCreated.uuid)
 
-    return videoCreated
+    return { videoCreated, videoWasAutoBlacklisted }
   })
 
-  Notifier.Instance.notifyOnNewVideo(videoCreated)
+  if (videoWasAutoBlacklisted) {
+    Notifier.Instance.notifyOnVideoAutoBlacklist(videoCreated)
+  } else {
+    Notifier.Instance.notifyOnNewVideo(videoCreated)
+  }
 
   if (video.state === VideoState.TO_TRANSCODE) {
     // Put uuid because we don't have id auto incremented for now
@@ -280,7 +284,7 @@ async function addVideo (req: express.Request, res: express.Response) {
       isNewVideo: true
     }
 
-    await JobQueue.Instance.createJob({ type: 'video-file', payload: dataInput })
+    await JobQueue.Instance.createJob({ type: 'video-transcoding', payload: dataInput })
   }
 
   return res.json({
@@ -292,7 +296,7 @@ async function addVideo (req: express.Request, res: express.Response) {
 }
 
 async function updateVideo (req: express.Request, res: express.Response) {
-  const videoInstance: VideoModel = res.locals.video
+  const videoInstance = res.locals.video
   const videoFieldsSave = videoInstance.toJSON()
   const oldVideoAuditView = new VideoAuditView(videoInstance.toFormattedDetailsJSON())
   const videoInfoToUpdate: VideoUpdate = req.body
@@ -300,16 +304,13 @@ async function updateVideo (req: express.Request, res: express.Response) {
   const wasUnlistedVideo = videoInstance.privacy === VideoPrivacy.UNLISTED
 
   // Process thumbnail or create it from the video
-  if (req.files && req.files['thumbnailfile']) {
-    const thumbnailPhysicalFile = req.files['thumbnailfile'][0]
-    await processImage(thumbnailPhysicalFile, join(CONFIG.STORAGE.THUMBNAILS_DIR, videoInstance.getThumbnailName()), THUMBNAILS_SIZE)
-  }
+  const thumbnailModel = req.files && req.files['thumbnailfile']
+    ? await createVideoMiniatureFromExisting(req.files['thumbnailfile'][0].path, videoInstance, ThumbnailType.MINIATURE)
+    : undefined
 
-  // Process preview or create it from the video
-  if (req.files && req.files['previewfile']) {
-    const previewPhysicalFile = req.files['previewfile'][0]
-    await processImage(previewPhysicalFile, join(CONFIG.STORAGE.PREVIEWS_DIR, videoInstance.getPreviewName()), PREVIEWS_SIZE)
-  }
+  const previewModel = req.files && req.files['previewfile']
+    ? await createVideoMiniatureFromExisting(req.files['previewfile'][0].path, videoInstance, ThumbnailType.PREVIEW)
+    : undefined
 
   try {
     const videoInstanceUpdated = await sequelizeTypescript.transaction(async t => {
@@ -325,17 +326,26 @@ async function updateVideo (req: express.Request, res: express.Response) {
       if (videoInfoToUpdate.support !== undefined) videoInstance.set('support', videoInfoToUpdate.support)
       if (videoInfoToUpdate.description !== undefined) videoInstance.set('description', videoInfoToUpdate.description)
       if (videoInfoToUpdate.commentsEnabled !== undefined) videoInstance.set('commentsEnabled', videoInfoToUpdate.commentsEnabled)
+      if (videoInfoToUpdate.downloadEnabled !== undefined) videoInstance.set('downloadEnabled', videoInfoToUpdate.downloadEnabled)
+
+      if (videoInfoToUpdate.originallyPublishedAt !== undefined && videoInfoToUpdate.originallyPublishedAt !== null) {
+        videoInstance.originallyPublishedAt = new Date(videoInfoToUpdate.originallyPublishedAt)
+      }
+
       if (videoInfoToUpdate.privacy !== undefined) {
         const newPrivacy = parseInt(videoInfoToUpdate.privacy.toString(), 10)
-        videoInstance.set('privacy', newPrivacy)
+        videoInstance.privacy = newPrivacy
 
         if (wasPrivateVideo === true && newPrivacy !== VideoPrivacy.PRIVATE) {
-          videoInstance.set('publishedAt', new Date())
+          videoInstance.publishedAt = new Date()
         }
       }
 
       const videoInstanceUpdated = await videoInstance.save(sequelizeOptions)
 
+      if (thumbnailModel) await videoInstanceUpdated.addAndSaveThumbnail(thumbnailModel, t)
+      if (previewModel) await videoInstanceUpdated.addAndSaveThumbnail(previewModel, t)
+
       // Video tags update?
       if (videoInfoToUpdate.tags !== undefined) {
         const tagInstances = await TagModel.findOrCreateTags(videoInfoToUpdate.tags, t)
@@ -395,22 +405,24 @@ async function updateVideo (req: express.Request, res: express.Response) {
   return res.type('json').status(204).end()
 }
 
-function getVideo (req: express.Request, res: express.Response) {
-  const videoInstance = res.locals.video
+async function getVideo (req: express.Request, res: express.Response) {
+  // We need more attributes
+  const userId: number = res.locals.oauth ? res.locals.oauth.token.User.id : null
+  const video = await VideoModel.loadForGetAPI(res.locals.video.id, undefined, userId)
 
-  if (videoInstance.isOutdated()) {
-    JobQueue.Instance.createJob({ type: 'activitypub-refresher', payload: { type: 'video', url: videoInstance.url } })
-      .catch(err => logger.error('Cannot create AP refresher job for video %s.', videoInstance.url, { err }))
+  if (video.isOutdated()) {
+    JobQueue.Instance.createJob({ type: 'activitypub-refresher', payload: { type: 'video', url: video.url } })
+      .catch(err => logger.error('Cannot create AP refresher job for video %s.', video.url, { err }))
   }
 
-  return res.json(videoInstance.toFormattedDetailsJSON())
+  return res.json(video.toFormattedDetailsJSON())
 }
 
 async function viewVideo (req: express.Request, res: express.Response) {
   const videoInstance = res.locals.video
 
   const ip = req.ip
-  const exists = await Redis.Instance.isVideoIPViewExists(ip, videoInstance.uuid)
+  const exists = await Redis.Instance.doesVideoIPViewExist(ip, videoInstance.uuid)
   if (exists) {
     logger.debug('View for ip %s and video %s already exists.', ip, videoInstance.uuid)
     return res.status(204).end()
@@ -422,7 +434,7 @@ async function viewVideo (req: express.Request, res: express.Response) {
   ])
 
   const serverActor = await getServerActor()
-  await sendCreateView(serverActor, videoInstance, undefined)
+  await sendView(serverActor, videoInstance, undefined)
 
   return res.status(204).end()
 }
@@ -461,7 +473,7 @@ async function listVideos (req: express.Request, res: express.Response) {
 }
 
 async function removeVideo (req: express.Request, res: express.Response) {
-  const videoInstance: VideoModel = res.locals.video
+  const videoInstance = res.locals.video
 
   await sequelizeTypescript.transaction(async t => {
     await videoInstance.destroy({ transaction: t })
diff --git a/server/controllers/api/videos/ownership.ts b/server/controllers/api/videos/ownership.ts
index 5ea7d7c6a..5272c1385 100644
--- a/server/controllers/api/videos/ownership.ts
+++ b/server/controllers/api/videos/ownership.ts
@@ -11,15 +11,13 @@ import {
   videosChangeOwnershipValidator,
   videosTerminateChangeOwnershipValidator
 } from '../../../middlewares'
-import { AccountModel } from '../../../models/account/account'
-import { VideoModel } from '../../../models/video/video'
 import { VideoChangeOwnershipModel } from '../../../models/video/video-change-ownership'
 import { VideoChangeOwnershipStatus, VideoPrivacy, VideoState } from '../../../../shared/models/videos'
 import { VideoChannelModel } from '../../../models/video/video-channel'
 import { getFormattedObjects } from '../../../helpers/utils'
 import { changeVideoChannelShare } from '../../../lib/activitypub'
 import { sendUpdateVideo } from '../../../lib/activitypub/send'
-import { UserModel } from '../../../models/account/user'
+import { VideoModel } from '../../../models/video/video'
 
 const ownershipVideoRouter = express.Router()
 
@@ -58,9 +56,9 @@ export {
 // ---------------------------------------------------------------------------
 
 async function giveVideoOwnership (req: express.Request, res: express.Response) {
-  const videoInstance = res.locals.video as VideoModel
-  const initiatorAccountId = (res.locals.oauth.token.User as UserModel).Account.id
-  const nextOwner = res.locals.nextOwner as AccountModel
+  const videoInstance = res.locals.video
+  const initiatorAccountId = res.locals.oauth.token.User.Account.id
+  const nextOwner = res.locals.nextOwner
 
   await sequelizeTypescript.transaction(t => {
     return VideoChangeOwnershipModel.findOrCreate({
@@ -85,7 +83,7 @@ async function giveVideoOwnership (req: express.Request, res: express.Response)
 }
 
 async function listVideoOwnership (req: express.Request, res: express.Response) {
-  const currentAccountId = (res.locals.oauth.token.User as UserModel).Account.id
+  const currentAccountId = res.locals.oauth.token.User.Account.id
 
   const resultList = await VideoChangeOwnershipModel.listForApi(
     currentAccountId,
@@ -99,13 +97,16 @@ async function listVideoOwnership (req: express.Request, res: express.Response)
 
 async function acceptOwnership (req: express.Request, res: express.Response) {
   return sequelizeTypescript.transaction(async t => {
-    const videoChangeOwnership = res.locals.videoChangeOwnership as VideoChangeOwnershipModel
-    const targetVideo = videoChangeOwnership.Video
-    const channel = res.locals.videoChannel as VideoChannelModel
+    const videoChangeOwnership = res.locals.videoChangeOwnership
+    const channel = res.locals.videoChannel
+
+    // We need more attributes for federation
+    const targetVideo = await VideoModel.loadAndPopulateAccountAndServerAndTags(videoChangeOwnership.Video.id)
 
     const oldVideoChannel = await VideoChannelModel.loadByIdAndPopulateAccount(targetVideo.channelId)
 
-    targetVideo.set('channelId', channel.id)
+    targetVideo.channelId = channel.id
+
     const targetVideoUpdated = await targetVideo.save({ transaction: t })
     targetVideoUpdated.VideoChannel = channel
 
@@ -114,7 +115,7 @@ async function acceptOwnership (req: express.Request, res: express.Response) {
       await sendUpdateVideo(targetVideoUpdated, t, oldVideoChannel.Account.Actor)
     }
 
-    videoChangeOwnership.set('status', VideoChangeOwnershipStatus.ACCEPTED)
+    videoChangeOwnership.status = VideoChangeOwnershipStatus.ACCEPTED
     await videoChangeOwnership.save({ transaction: t })
 
     return res.sendStatus(204)
@@ -123,9 +124,9 @@ async function acceptOwnership (req: express.Request, res: express.Response) {
 
 async function refuseOwnership (req: express.Request, res: express.Response) {
   return sequelizeTypescript.transaction(async t => {
-    const videoChangeOwnership = res.locals.videoChangeOwnership as VideoChangeOwnershipModel
+    const videoChangeOwnership = res.locals.videoChangeOwnership
 
-    videoChangeOwnership.set('status', VideoChangeOwnershipStatus.REFUSED)
+    videoChangeOwnership.status = VideoChangeOwnershipStatus.REFUSED
     await videoChangeOwnership.save({ transaction: t })
 
     return res.sendStatus(204)
diff --git a/server/controllers/api/videos/rate.ts b/server/controllers/api/videos/rate.ts
index 53952a0a2..b65babedf 100644
--- a/server/controllers/api/videos/rate.ts
+++ b/server/controllers/api/videos/rate.ts
@@ -1,12 +1,12 @@
 import * as express from 'express'
 import { UserVideoRateUpdate } from '../../../../shared'
 import { logger } from '../../../helpers/logger'
-import { sequelizeTypescript, VIDEO_RATE_TYPES } from '../../../initializers'
+import { VIDEO_RATE_TYPES } from '../../../initializers/constants'
 import { getRateUrl, sendVideoRateChange } from '../../../lib/activitypub'
 import { asyncMiddleware, asyncRetryTransactionMiddleware, authenticate, videoUpdateRateValidator } from '../../../middlewares'
 import { AccountModel } from '../../../models/account/account'
 import { AccountVideoRateModel } from '../../../models/account/account-video-rate'
-import { VideoModel } from '../../../models/video/video'
+import { sequelizeTypescript } from '../../../initializers/database'
 
 const rateVideoRouter = express.Router()
 
@@ -27,8 +27,8 @@ export {
 async function rateVideo (req: express.Request, res: express.Response) {
   const body: UserVideoRateUpdate = req.body
   const rateType = body.rating
-  const videoInstance: VideoModel = res.locals.video
-  const userAccount: AccountModel = res.locals.oauth.token.User.Account
+  const videoInstance = res.locals.video
+  const userAccount = res.locals.oauth.token.User.Account
 
   await sequelizeTypescript.transaction(async t => {
     const sequelizeOptions = { transaction: t }
diff --git a/server/controllers/api/videos/watching.ts b/server/controllers/api/videos/watching.ts
index e8876b47a..dcd1f070d 100644
--- a/server/controllers/api/videos/watching.ts
+++ b/server/controllers/api/videos/watching.ts
@@ -2,7 +2,6 @@ import * as express from 'express'
 import { UserWatchingVideo } from '../../../../shared'
 import { asyncMiddleware, asyncRetryTransactionMiddleware, authenticate, videoWatchingValidator } from '../../../middlewares'
 import { UserVideoHistoryModel } from '../../../models/account/user-video-history'
-import { UserModel } from '../../../models/account/user'
 
 const watchingRouter = express.Router()
 
@@ -21,7 +20,7 @@ export {
 // ---------------------------------------------------------------------------
 
 async function userWatchVideo (req: express.Request, res: express.Response) {
-  const user = res.locals.oauth.token.User as UserModel
+  const user = res.locals.oauth.token.User
 
   const body: UserWatchingVideo = req.body
   const { id: videoId } = res.locals.video as { id: number }
diff --git a/server/controllers/bots.ts b/server/controllers/bots.ts
index 2db86a2d8..e25d9c21b 100644
--- a/server/controllers/bots.ts
+++ b/server/controllers/bots.ts
@@ -1,6 +1,6 @@
 import * as express from 'express'
 import { asyncMiddleware } from '../middlewares'
-import { CONFIG, ROUTE_CACHE_LIFETIME } from '../initializers'
+import { ROUTE_CACHE_LIFETIME, WEBSERVER } from '../initializers/constants'
 import * as sitemapModule from 'sitemap'
 import { logger } from '../helpers/logger'
 import { VideoModel } from '../models/video/video'
@@ -35,7 +35,7 @@ async function getSitemap (req: express.Request, res: express.Response) {
   urls = urls.concat(await getSitemapAccountUrls())
 
   const sitemap = sitemapModule.createSitemap({
-    hostname: CONFIG.WEBSERVER.URL,
+    hostname: WEBSERVER.URL,
     urls: urls
   })
 
@@ -54,7 +54,7 @@ async function getSitemapVideoChannelUrls () {
   const rows = await VideoChannelModel.listLocalsForSitemap('createdAt')
 
   return rows.map(channel => ({
-    url: CONFIG.WEBSERVER.URL + '/video-channels/' + channel.Actor.preferredUsername
+    url: WEBSERVER.URL + '/video-channels/' + channel.Actor.preferredUsername
   }))
 }
 
@@ -62,7 +62,7 @@ async function getSitemapAccountUrls () {
   const rows = await AccountModel.listLocalsForSitemap('createdAt')
 
   return rows.map(channel => ({
-    url: CONFIG.WEBSERVER.URL + '/accounts/' + channel.Actor.preferredUsername
+    url: WEBSERVER.URL + '/accounts/' + channel.Actor.preferredUsername
   }))
 }
 
@@ -78,14 +78,14 @@ async function getSitemapLocalVideoUrls () {
   })
 
   return resultList.data.map(v => ({
-    url: CONFIG.WEBSERVER.URL + '/videos/watch/' + v.uuid,
+    url: WEBSERVER.URL + '/videos/watch/' + v.uuid,
     video: [
       {
         title: v.name,
         // Sitemap description should be < 2000 characters
         description: truncate(v.description || v.name, { length: 2000, omission: '...' }),
-        player_loc: CONFIG.WEBSERVER.URL + '/videos/embed/' + v.uuid,
-        thumbnail_loc: CONFIG.WEBSERVER.URL + v.getThumbnailStaticPath()
+        player_loc: WEBSERVER.URL + '/videos/embed/' + v.uuid,
+        thumbnail_loc: WEBSERVER.URL + v.getMiniatureStaticPath()
       }
     ]
   }))
@@ -97,5 +97,5 @@ function getSitemapBasicUrls () {
     '/videos/local'
   ]
 
-  return paths.map(p => ({ url: CONFIG.WEBSERVER.URL + p }))
+  return paths.map(p => ({ url: WEBSERVER.URL + p }))
 }
diff --git a/server/controllers/client.ts b/server/controllers/client.ts
index f17f2a5d2..f51470b41 100644
--- a/server/controllers/client.ts
+++ b/server/controllers/client.ts
@@ -1,7 +1,7 @@
 import * as express from 'express'
 import { join } from 'path'
 import { root } from '../helpers/core-utils'
-import { ACCEPT_HEADERS, STATIC_MAX_AGE } from '../initializers'
+import { ACCEPT_HEADERS, STATIC_MAX_AGE } from '../initializers/constants'
 import { asyncMiddleware, embedCSP } from '../middlewares'
 import { buildFileLocale, getCompleteLocale, is18nLocale, LOCALE_FILES } from '../../shared/models/i18n/i18n'
 import { ClientHtml } from '../lib/client-html'
@@ -17,6 +17,8 @@ const testEmbedPath = join(distPath, 'standalone', 'videos', 'test-embed.html')
 // Special route that add OpenGraph and oEmbed tags
 // Do not use a template engine for a so little thing
 clientsRouter.use('/videos/watch/:id', asyncMiddleware(generateWatchHtmlPage))
+clientsRouter.use('/accounts/:nameWithHost', asyncMiddleware(generateAccountHtmlPage))
+clientsRouter.use('/video-channels/:nameWithHost', asyncMiddleware(generateVideoChannelHtmlPage))
 
 clientsRouter.use(
   '/videos/embed',
@@ -99,6 +101,18 @@ async function generateWatchHtmlPage (req: express.Request, res: express.Respons
   return sendHTML(html, res)
 }
 
+async function generateAccountHtmlPage (req: express.Request, res: express.Response) {
+  const html = await ClientHtml.getAccountHTMLPage(req.params.nameWithHost, req, res)
+
+  return sendHTML(html, res)
+}
+
+async function generateVideoChannelHtmlPage (req: express.Request, res: express.Response) {
+  const html = await ClientHtml.getVideoChannelHTMLPage(req.params.nameWithHost, req, res)
+
+  return sendHTML(html, res)
+}
+
 function sendHTML (html: string, res: express.Response) {
   res.set('Content-Type', 'text/html; charset=UTF-8')
 
diff --git a/server/controllers/feeds.ts b/server/controllers/feeds.ts
index 960085af1..d3f581615 100644
--- a/server/controllers/feeds.ts
+++ b/server/controllers/feeds.ts
@@ -1,6 +1,5 @@
 import * as express from 'express'
-import { CONFIG, FEEDS, ROUTE_CACHE_LIFETIME } from '../initializers/constants'
-import { THUMBNAILS_SIZE } from '../initializers'
+import { FEEDS, ROUTE_CACHE_LIFETIME, THUMBNAILS_SIZE, WEBSERVER } from '../initializers/constants'
 import {
   asyncMiddleware,
   commonVideosFiltersValidator,
@@ -11,11 +10,10 @@ import {
 } from '../middlewares'
 import { VideoModel } from '../models/video/video'
 import * as Feed from 'pfeed'
-import { AccountModel } from '../models/account/account'
 import { cacheRoute } from '../middlewares/cache'
-import { VideoChannelModel } from '../models/video/video-channel'
 import { VideoCommentModel } from '../models/video/video-comment'
 import { buildNSFWFilter } from '../helpers/express-utils'
+import { CONFIG } from '../initializers/config'
 
 const feedsRouter = express.Router()
 
@@ -42,10 +40,10 @@ export {
 
 // ---------------------------------------------------------------------------
 
-async function generateVideoCommentsFeed (req: express.Request, res: express.Response, next: express.NextFunction) {
+async function generateVideoCommentsFeed (req: express.Request, res: express.Response) {
   const start = 0
 
-  const video = res.locals.video as VideoModel
+  const video = res.locals.video
   const videoId: number = video ? video.id : undefined
 
   const comments = await VideoCommentModel.listForFeed(start, FEEDS.COUNT, videoId)
@@ -56,7 +54,7 @@ async function generateVideoCommentsFeed (req: express.Request, res: express.Res
 
   // Adding video items to the feed, one at a time
   comments.forEach(comment => {
-    const link = CONFIG.WEBSERVER.URL + comment.getCommentStaticPath()
+    const link = WEBSERVER.URL + comment.getCommentStaticPath()
 
     feed.addItem({
       title: `${comment.Video.name} - ${comment.Account.getDisplayName()}`,
@@ -77,11 +75,11 @@ async function generateVideoCommentsFeed (req: express.Request, res: express.Res
   return sendFeed(feed, req, res)
 }
 
-async function generateVideoFeed (req: express.Request, res: express.Response, next: express.NextFunction) {
+async function generateVideoFeed (req: express.Request, res: express.Response) {
   const start = 0
 
-  const account: AccountModel = res.locals.account
-  const videoChannel: VideoChannelModel = res.locals.videoChannel
+  const account = res.locals.account
+  const videoChannel = res.locals.videoChannel
   const nsfw = buildNSFWFilter(res, req.query.nsfw)
 
   let name: string
@@ -124,7 +122,7 @@ async function generateVideoFeed (req: express.Request, res: express.Response, n
     feed.addItem({
       title: video.name,
       id: video.url,
-      link: CONFIG.WEBSERVER.URL + '/videos/watch/' + video.uuid,
+      link: WEBSERVER.URL + '/videos/watch/' + video.uuid,
       description: video.getTruncatedDescription(),
       content: video.description,
       author: [
@@ -139,7 +137,7 @@ async function generateVideoFeed (req: express.Request, res: express.Response, n
       torrent: torrents,
       thumbnail: [
         {
-          url: CONFIG.WEBSERVER.URL + video.getThumbnailStaticPath(),
+          url: WEBSERVER.URL + video.getMiniatureStaticPath(),
           height: THUMBNAILS_SIZE.height,
           width: THUMBNAILS_SIZE.width
         }
@@ -152,7 +150,7 @@ async function generateVideoFeed (req: express.Request, res: express.Response, n
 }
 
 function initFeed (name: string, description: string) {
-  const webserverUrl = CONFIG.WEBSERVER.URL
+  const webserverUrl = WEBSERVER.URL
 
   return new Feed({
     title: name,
diff --git a/server/controllers/services.ts b/server/controllers/services.ts
index 352d0b19a..c1c53c3fc 100644
--- a/server/controllers/services.ts
+++ b/server/controllers/services.ts
@@ -1,8 +1,7 @@
 import * as express from 'express'
-import { CONFIG, EMBED_SIZE, PREVIEWS_SIZE } from '../initializers'
+import { EMBED_SIZE, PREVIEWS_SIZE, WEBSERVER } from '../initializers/constants'
 import { asyncMiddleware, oembedValidator } from '../middlewares'
-import { accountsNameWithHostGetValidator } from '../middlewares/validators'
-import { VideoModel } from '../models/video/video'
+import { accountNameWithHostGetValidator } from '../middlewares/validators'
 
 const servicesRouter = express.Router()
 
@@ -11,7 +10,7 @@ servicesRouter.use('/oembed',
   generateOEmbed
 )
 servicesRouter.use('/redirect/accounts/:accountName',
-  asyncMiddleware(accountsNameWithHostGetValidator),
+  asyncMiddleware(accountNameWithHostGetValidator),
   redirectToAccountUrl
 )
 
@@ -23,9 +22,9 @@ export {
 
 // ---------------------------------------------------------------------------
 
-function generateOEmbed (req: express.Request, res: express.Response, next: express.NextFunction) {
-  const video = res.locals.video as VideoModel
-  const webserverUrl = CONFIG.WEBSERVER.URL
+function generateOEmbed (req: express.Request, res: express.Response) {
+  const video = res.locals.video
+  const webserverUrl = WEBSERVER.URL
   const maxHeight = parseInt(req.query.maxheight, 10)
   const maxWidth = parseInt(req.query.maxwidth, 10)
 
diff --git a/server/controllers/static.ts b/server/controllers/static.ts
index 4fd58f70c..05019fcc2 100644
--- a/server/controllers/static.ts
+++ b/server/controllers/static.ts
@@ -1,16 +1,23 @@
 import * as cors from 'cors'
 import * as express from 'express'
-import { CONFIG, ROUTE_CACHE_LIFETIME, STATIC_DOWNLOAD_PATHS, STATIC_MAX_AGE, STATIC_PATHS } from '../initializers'
-import { VideosPreviewCache } from '../lib/cache'
+import {
+  HLS_STREAMING_PLAYLIST_DIRECTORY,
+  ROUTE_CACHE_LIFETIME,
+  STATIC_DOWNLOAD_PATHS,
+  STATIC_MAX_AGE,
+  STATIC_PATHS,
+  WEBSERVER
+} from '../initializers/constants'
+import { VideosCaptionCache, VideosPreviewCache } from '../lib/files-cache'
 import { cacheRoute } from '../middlewares/cache'
 import { asyncMiddleware, videosGetValidator } from '../middlewares'
 import { VideoModel } from '../models/video/video'
-import { VideosCaptionCache } from '../lib/cache/videos-caption-cache'
 import { UserModel } from '../models/account/user'
 import { VideoCommentModel } from '../models/video/video-comment'
 import { HttpNodeinfoDiasporaSoftwareNsSchema20 } from '../../shared/models/nodeinfo'
 import { join } from 'path'
 import { root } from '../helpers/core-utils'
+import { CONFIG } from '../initializers/config'
 
 const packageJSON = require('../../../package.json')
 const staticRouter = express.Router()
@@ -51,6 +58,13 @@ staticRouter.use(
   asyncMiddleware(downloadVideoFile)
 )
 
+// HLS
+staticRouter.use(
+  STATIC_PATHS.STREAMING_PLAYLISTS.HLS,
+  cors(),
+  express.static(HLS_STREAMING_PLAYLIST_DIRECTORY, { fallthrough: false }) // 404 if the file does not exist
+)
+
 // Thumbnails path for express
 const thumbnailsPhysicalPath = CONFIG.STORAGE.THUMBNAILS_DIR
 staticRouter.use(
@@ -108,7 +122,7 @@ staticRouter.use('/.well-known/nodeinfo',
       links: [
         {
           rel: 'http://nodeinfo.diaspora.software/ns/schema/2.0',
-          href: CONFIG.WEBSERVER.URL + '/nodeinfo/2.0.json'
+          href: WEBSERVER.URL + '/nodeinfo/2.0.json'
         }
       ]
     })
@@ -150,21 +164,21 @@ export {
 
 // ---------------------------------------------------------------------------
 
-async function getPreview (req: express.Request, res: express.Response, next: express.NextFunction) {
-  const path = await VideosPreviewCache.Instance.getFilePath(req.params.uuid)
-  if (!path) return res.sendStatus(404)
+async function getPreview (req: express.Request, res: express.Response) {
+  const result = await VideosPreviewCache.Instance.getFilePath(req.params.uuid)
+  if (!result) return res.sendStatus(404)
 
-  return res.sendFile(path, { maxAge: STATIC_MAX_AGE })
+  return res.sendFile(result.path, { maxAge: STATIC_MAX_AGE })
 }
 
 async function getVideoCaption (req: express.Request, res: express.Response) {
-  const path = await VideosCaptionCache.Instance.getFilePath({
+  const result = await VideosCaptionCache.Instance.getFilePath({
     videoId: req.params.videoId,
     language: req.params.captionLanguage
   })
-  if (!path) return res.sendStatus(404)
+  if (!result) return res.sendStatus(404)
 
-  return res.sendFile(path, { maxAge: STATIC_MAX_AGE })
+  return res.sendFile(result.path, { maxAge: STATIC_MAX_AGE })
 }
 
 async function generateNodeinfo (req: express.Request, res: express.Response, next: express.NextFunction) {
@@ -231,7 +245,7 @@ async function downloadVideoFile (req: express.Request, res: express.Response, n
 
 function getVideoAndFile (req: express.Request, res: express.Response) {
   const resolution = parseInt(req.params.resolution, 10)
-  const video: VideoModel = res.locals.video
+  const video = res.locals.video
 
   const videoFile = video.VideoFiles.find(f => f.resolution === resolution)
 
diff --git a/server/controllers/tracker.ts b/server/controllers/tracker.ts
index 1deb8c402..912f82b86 100644
--- a/server/controllers/tracker.ts
+++ b/server/controllers/tracker.ts
@@ -4,9 +4,11 @@ import * as http from 'http'
 import * as bitTorrentTracker from 'bittorrent-tracker'
 import * as proxyAddr from 'proxy-addr'
 import { Server as WebSocketServer } from 'ws'
-import { CONFIG, TRACKER_RATE_LIMITS } from '../initializers/constants'
+import { TRACKER_RATE_LIMITS } from '../initializers/constants'
 import { VideoFileModel } from '../models/video/video-file'
 import { parse } from 'url'
+import { VideoStreamingPlaylistModel } from '../models/video/video-streaming-playlist'
+import { CONFIG } from '../initializers/config'
 
 const TrackerServer = bitTorrentTracker.Server
 
@@ -21,7 +23,11 @@ const trackerServer = new TrackerServer({
   udp: false,
   ws: false,
   dht: false,
-  filter: function (infoHash, params, cb) {
+  filter: async function (infoHash, params, cb) {
+    if (CONFIG.TRACKER.ENABLED === false) {
+      return cb(new Error('Tracker is disabled on this instance.'))
+    }
+
     let ip: string
 
     if (params.type === 'ws') {
@@ -32,29 +38,40 @@ const trackerServer = new TrackerServer({
 
     const key = ip + '-' + infoHash
 
-    peersIps[ip] = peersIps[ip] ? peersIps[ip] + 1 : 1
-    peersIpInfoHash[key] = peersIpInfoHash[key] ? peersIpInfoHash[key] + 1 : 1
+    peersIps[ ip ] = peersIps[ ip ] ? peersIps[ ip ] + 1 : 1
+    peersIpInfoHash[ key ] = peersIpInfoHash[ key ] ? peersIpInfoHash[ key ] + 1 : 1
 
-    if (peersIpInfoHash[key] > TRACKER_RATE_LIMITS.ANNOUNCES_PER_IP_PER_INFOHASH) {
+    if (CONFIG.TRACKER.REJECT_TOO_MANY_ANNOUNCES && peersIpInfoHash[ key ] > TRACKER_RATE_LIMITS.ANNOUNCES_PER_IP_PER_INFOHASH) {
       return cb(new Error(`Too many requests (${peersIpInfoHash[ key ]} of ip ${ip} for torrent ${infoHash}`))
     }
 
-    VideoFileModel.isInfohashExists(infoHash)
-      .then(exists => {
-        if (exists === false) return cb(new Error(`Unknown infoHash ${infoHash}`))
+    try {
+      if (CONFIG.TRACKER.PRIVATE === false) return cb()
+
+      const videoFileExists = await VideoFileModel.doesInfohashExist(infoHash)
+      if (videoFileExists === true) return cb()
 
-        return cb()
-      })
+      const playlistExists = await VideoStreamingPlaylistModel.doesInfohashExist(infoHash)
+      if (playlistExists === true) return cb()
+
+      return cb(new Error(`Unknown infoHash ${infoHash}`))
+    } catch (err) {
+      logger.error('Error in tracker filter.', { err })
+      return cb(err)
+    }
   }
 })
 
-trackerServer.on('error', function (err) {
-  logger.error('Error in tracker.', { err })
-})
+if (CONFIG.TRACKER.ENABLED !== false) {
 
-trackerServer.on('warning', function (err) {
-  logger.warn('Warning in tracker.', { err })
-})
+  trackerServer.on('error', function (err) {
+    logger.error('Error in tracker.', { err })
+  })
+
+  trackerServer.on('warning', function (err) {
+    logger.warn('Warning in tracker.', { err })
+  })
+}
 
 const onHttpRequest = trackerServer.onHttpRequest.bind(trackerServer)
 trackerRouter.get('/tracker/announce', (req, res) => onHttpRequest(req, res, { action: 'announce' }))
diff --git a/server/controllers/webfinger.ts b/server/controllers/webfinger.ts
index ed781c21b..f2ba3c826 100644
--- a/server/controllers/webfinger.ts
+++ b/server/controllers/webfinger.ts
@@ -1,7 +1,6 @@
 import * as express from 'express'
 import { asyncMiddleware } from '../middlewares'
 import { webfingerValidator } from '../middlewares/validators'
-import { ActorModel } from '../models/activitypub/actor'
 
 const webfingerRouter = express.Router()
 
@@ -18,8 +17,8 @@ export {
 
 // ---------------------------------------------------------------------------
 
-function webfingerController (req: express.Request, res: express.Response, next: express.NextFunction) {
-  const actor = res.locals.actor as ActorModel
+function webfingerController (req: express.Request, res: express.Response) {
+  const actor = res.locals.actor
 
   const json = {
     subject: req.query.resource,
diff --git a/server/helpers/activitypub.ts b/server/helpers/activitypub.ts
index f1430055f..951a25669 100644
--- a/server/helpers/activitypub.ts
+++ b/server/helpers/activitypub.ts
@@ -2,7 +2,7 @@ import * as Bluebird from 'bluebird'
 import * as validator from 'validator'
 import { ResultList } from '../../shared/models'
 import { Activity } from '../../shared/models/activitypub'
-import { ACTIVITY_PUB } from '../initializers'
+import { ACTIVITY_PUB } from '../initializers/constants'
 import { ActorModel } from '../models/activitypub/actor'
 import { signJsonLDObject } from './peertube-crypto'
 import { pageToStartAndCount } from './core-utils'
@@ -15,7 +15,7 @@ function activityPubContextify <T> (data: T) {
       'https://w3id.org/security/v1',
       {
         RsaSignature2017: 'https://w3id.org/security#RsaSignature2017',
-        pt: 'https://joinpeertube.org/ns',
+        pt: 'https://joinpeertube.org/ns#',
         sc: 'http://schema.org#',
         Hashtag: 'as:Hashtag',
         uuid: 'sc:identifier',
@@ -24,15 +24,54 @@ function activityPubContextify <T> (data: T) {
         subtitleLanguage: 'sc:subtitleLanguage',
         sensitive: 'as:sensitive',
         language: 'sc:inLanguage',
-        views: 'sc:Number',
-        state: 'sc:Number',
-        size: 'sc:Number',
-        fps: 'sc:Number',
-        commentsEnabled: 'sc:Boolean',
-        waitTranscoding: 'sc:Boolean',
         expires: 'sc:expires',
-        support: 'sc:Text',
-        CacheFile: 'pt:CacheFile'
+        CacheFile: 'pt:CacheFile',
+        Infohash: 'pt:Infohash',
+        originallyPublishedAt: 'sc:datePublished',
+        views: {
+          '@type': 'sc:Number',
+          '@id': 'pt:views'
+        },
+        state: {
+          '@type': 'sc:Number',
+          '@id': 'pt:state'
+        },
+        size: {
+          '@type': 'sc:Number',
+          '@id': 'pt:size'
+        },
+        fps: {
+          '@type': 'sc:Number',
+          '@id': 'pt:fps'
+        },
+        startTimestamp: {
+          '@type': 'sc:Number',
+          '@id': 'pt:startTimestamp'
+        },
+        stopTimestamp: {
+          '@type': 'sc:Number',
+          '@id': 'pt:stopTimestamp'
+        },
+        position: {
+          '@type': 'sc:Number',
+          '@id': 'pt:position'
+        },
+        commentsEnabled: {
+          '@type': 'sc:Boolean',
+          '@id': 'pt:commentsEnabled'
+        },
+        downloadEnabled: {
+          '@type': 'sc:Boolean',
+          '@id': 'pt:downloadEnabled'
+        },
+        waitTranscoding: {
+          '@type': 'sc:Boolean',
+          '@id': 'pt:waitTranscoding'
+        },
+        support: {
+          '@type': 'sc:Text',
+          '@id': 'pt:support'
+        }
       },
       {
         likes: {
@@ -43,6 +82,10 @@ function activityPubContextify <T> (data: T) {
           '@id': 'as:dislikes',
           '@type': '@id'
         },
+        playlists: {
+          '@id': 'pt:playlists',
+          '@type': '@id'
+        },
         shares: {
           '@id': 'as:shares',
           '@type': '@id'
@@ -64,7 +107,7 @@ async function activityPubCollectionPagination (baseUrl: string, handler: Activi
 
     return {
       id: baseUrl,
-      type: 'OrderedCollection',
+      type: 'OrderedCollectionPage',
       totalItems: result.total,
       first: baseUrl + '?page=1'
     }
diff --git a/server/helpers/audit-logger.ts b/server/helpers/audit-logger.ts
index 00311fce1..f536da439 100644
--- a/server/helpers/audit-logger.ts
+++ b/server/helpers/audit-logger.ts
@@ -4,15 +4,14 @@ import { diff } from 'deep-object-diff'
 import { chain } from 'lodash'
 import * as flatten from 'flat'
 import * as winston from 'winston'
-import { CONFIG } from '../initializers'
 import { jsonLoggerFormat, labelFormatter } from './logger'
-import { VideoDetails, User, VideoChannel, VideoAbuse, VideoImport } from '../../shared'
+import { User, VideoAbuse, VideoChannel, VideoDetails, VideoImport } from '../../shared'
 import { VideoComment } from '../../shared/models/videos/video-comment.model'
 import { CustomConfig } from '../../shared/models/server/custom-config.model'
-import { UserModel } from '../models/account/user'
+import { CONFIG } from '../initializers/config'
 
 function getAuditIdFromRes (res: express.Response) {
-  return (res.locals.oauth.token.User as UserModel).username
+  return res.locals.oauth.token.User.username
 }
 
 enum AUDIT_TYPE {
@@ -117,7 +116,8 @@ const videoKeysToKeep = [
   'channel-uuid',
   'channel-name',
   'support',
-  'commentsEnabled'
+  'commentsEnabled',
+  'downloadEnabled'
 ]
 class VideoAuditView extends EntityAuditView {
   constructor (private video: VideoDetails) {
diff --git a/server/helpers/captions-utils.ts b/server/helpers/captions-utils.ts
index 0fb11a125..7174d4654 100644
--- a/server/helpers/captions-utils.ts
+++ b/server/helpers/captions-utils.ts
@@ -1,5 +1,5 @@
 import { join } from 'path'
-import { CONFIG } from '../initializers'
+import { CONFIG } from '../initializers/config'
 import { VideoCaptionModel } from '../models/video/video-caption'
 import * as srt2vtt from 'srt-to-vtt'
 import { createReadStream, createWriteStream, remove, move } from 'fs-extra'
diff --git a/server/helpers/core-utils.ts b/server/helpers/core-utils.ts
index 3fb824e36..305d3b71e 100644
--- a/server/helpers/core-utils.ts
+++ b/server/helpers/core-utils.ts
@@ -11,14 +11,13 @@ import * as pem from 'pem'
 import { URL } from 'url'
 import { truncate } from 'lodash'
 import { exec } from 'child_process'
-import { isArray } from './custom-validators/misc'
 
 const objectConverter = (oldObject: any, keyConverter: (e: string) => string, valueConverter: (e: any) => any) => {
   if (!oldObject || typeof oldObject !== 'object') {
     return valueConverter(oldObject)
   }
 
-  if (isArray(oldObject)) {
+  if (Array.isArray(oldObject)) {
     return oldObject.map(e => objectConverter(e, keyConverter, valueConverter))
   }
 
@@ -41,7 +40,7 @@ const timeTable = {
   month:        3600000 * 24 * 30
 }
 
-export function parseDuration (duration: number | string): number {
+export function parseDurationToMs (duration: number | string): number {
   if (typeof duration === 'number') return duration
 
   if (typeof duration === 'string') {
@@ -58,7 +57,7 @@ export function parseDuration (duration: number | string): number {
     }
   }
 
-  throw new Error('Duration could not be properly parsed')
+  throw new Error(`Duration ${duration} could not be properly parsed`)
 }
 
 export function parseBytes (value: string | number): number {
@@ -193,10 +192,14 @@ function peertubeTruncate (str: string, maxLength: number) {
   return truncate(str, options)
 }
 
-function sha256 (str: string, encoding: HexBase64Latin1Encoding = 'hex') {
+function sha256 (str: string | Buffer, encoding: HexBase64Latin1Encoding = 'hex') {
   return createHash('sha256').update(str).digest(encoding)
 }
 
+function sha1 (str: string | Buffer, encoding: HexBase64Latin1Encoding = 'hex') {
+  return createHash('sha1').update(str).digest(encoding)
+}
+
 function promisify0<A> (func: (cb: (err: any, result: A) => void) => void): () => Promise<A> {
   return function promisified (): Promise<A> {
     return new Promise<A>((resolve: (arg: A) => void, reject: (err: any) => void) => {
@@ -262,7 +265,9 @@ export {
   sanitizeHost,
   buildPath,
   peertubeTruncate,
+
   sha256,
+  sha1,
 
   promisify0,
   promisify1,
diff --git a/server/helpers/custom-jsonld-signature.ts b/server/helpers/custom-jsonld-signature.ts
index 27a187db1..a3bceb047 100644
--- a/server/helpers/custom-jsonld-signature.ts
+++ b/server/helpers/custom-jsonld-signature.ts
@@ -1,13 +1,77 @@
 import * as AsyncLRU from 'async-lru'
 import * as jsonld from 'jsonld'
 import * as jsig from 'jsonld-signatures'
+import { logger } from './logger'
+
+const CACHE = {
+  'https://w3id.org/security/v1': {
+    '@context': {
+      'id': '@id',
+      'type': '@type',
+
+      'dc': 'http://purl.org/dc/terms/',
+      'sec': 'https://w3id.org/security#',
+      'xsd': 'http://www.w3.org/2001/XMLSchema#',
+
+      'EcdsaKoblitzSignature2016': 'sec:EcdsaKoblitzSignature2016',
+      'Ed25519Signature2018': 'sec:Ed25519Signature2018',
+      'EncryptedMessage': 'sec:EncryptedMessage',
+      'GraphSignature2012': 'sec:GraphSignature2012',
+      'LinkedDataSignature2015': 'sec:LinkedDataSignature2015',
+      'LinkedDataSignature2016': 'sec:LinkedDataSignature2016',
+      'CryptographicKey': 'sec:Key',
+
+      'authenticationTag': 'sec:authenticationTag',
+      'canonicalizationAlgorithm': 'sec:canonicalizationAlgorithm',
+      'cipherAlgorithm': 'sec:cipherAlgorithm',
+      'cipherData': 'sec:cipherData',
+      'cipherKey': 'sec:cipherKey',
+      'created': { '@id': 'dc:created', '@type': 'xsd:dateTime' },
+      'creator': { '@id': 'dc:creator', '@type': '@id' },
+      'digestAlgorithm': 'sec:digestAlgorithm',
+      'digestValue': 'sec:digestValue',
+      'domain': 'sec:domain',
+      'encryptionKey': 'sec:encryptionKey',
+      'expiration': { '@id': 'sec:expiration', '@type': 'xsd:dateTime' },
+      'expires': { '@id': 'sec:expiration', '@type': 'xsd:dateTime' },
+      'initializationVector': 'sec:initializationVector',
+      'iterationCount': 'sec:iterationCount',
+      'nonce': 'sec:nonce',
+      'normalizationAlgorithm': 'sec:normalizationAlgorithm',
+      'owner': { '@id': 'sec:owner', '@type': '@id' },
+      'password': 'sec:password',
+      'privateKey': { '@id': 'sec:privateKey', '@type': '@id' },
+      'privateKeyPem': 'sec:privateKeyPem',
+      'publicKey': { '@id': 'sec:publicKey', '@type': '@id' },
+      'publicKeyBase58': 'sec:publicKeyBase58',
+      'publicKeyPem': 'sec:publicKeyPem',
+      'publicKeyWif': 'sec:publicKeyWif',
+      'publicKeyService': { '@id': 'sec:publicKeyService', '@type': '@id' },
+      'revoked': { '@id': 'sec:revoked', '@type': 'xsd:dateTime' },
+      'salt': 'sec:salt',
+      'signature': 'sec:signature',
+      'signatureAlgorithm': 'sec:signingAlgorithm',
+      'signatureValue': 'sec:signatureValue'
+    }
+  }
+}
 
 const nodeDocumentLoader = jsonld.documentLoaders.node()
 
 const lru = new AsyncLRU({
   max: 10,
-  load: (key, cb) => {
-    nodeDocumentLoader(key, cb)
+  load: (url, cb) => {
+    if (CACHE[ url ] !== undefined) {
+      logger.debug('Using cache for JSON-LD %s.', url)
+
+      return cb(null, {
+        contextUrl: null,
+        document: CACHE[ url ],
+        documentUrl: url
+      })
+    }
+
+    nodeDocumentLoader(url, cb)
   }
 })
 
diff --git a/server/helpers/custom-validators/accounts.ts b/server/helpers/custom-validators/accounts.ts
index 191de1496..146c7708e 100644
--- a/server/helpers/custom-validators/accounts.ts
+++ b/server/helpers/custom-validators/accounts.ts
@@ -5,7 +5,6 @@ import * as validator from 'validator'
 import { AccountModel } from '../../models/account/account'
 import { isUserDescriptionValid, isUserUsernameValid } from './users'
 import { exists } from './misc'
-import { CONFIG } from '../../initializers'
 
 function isAccountNameValid (value: string) {
   return isUserUsernameValid(value)
@@ -19,7 +18,7 @@ function isAccountDescriptionValid (value: string) {
   return isUserDescriptionValid(value)
 }
 
-function isAccountIdExist (id: number | string, res: Response, sendNotFound = true) {
+function doesAccountIdExist (id: number | string, res: Response, sendNotFound = true) {
   let promise: Bluebird<AccountModel>
 
   if (validator.isInt('' + id)) {
@@ -28,26 +27,20 @@ function isAccountIdExist (id: number | string, res: Response, sendNotFound = tr
     promise = AccountModel.loadByUUID('' + id)
   }
 
-  return isAccountExist(promise, res, sendNotFound)
+  return doesAccountExist(promise, res, sendNotFound)
 }
 
-function isLocalAccountNameExist (name: string, res: Response, sendNotFound = true) {
+function doesLocalAccountNameExist (name: string, res: Response, sendNotFound = true) {
   const promise = AccountModel.loadLocalByName(name)
 
-  return isAccountExist(promise, res, sendNotFound)
+  return doesAccountExist(promise, res, sendNotFound)
 }
 
-function isAccountNameWithHostExist (nameWithDomain: string, res: Response, sendNotFound = true) {
-  const [ accountName, host ] = nameWithDomain.split('@')
-
-  let promise: Bluebird<AccountModel>
-  if (!host || host === CONFIG.WEBSERVER.HOST) promise = AccountModel.loadLocalByName(accountName)
-  else promise = AccountModel.loadByNameAndHost(accountName, host)
-
-  return isAccountExist(promise, res, sendNotFound)
+function doesAccountNameWithHostExist (nameWithDomain: string, res: Response, sendNotFound = true) {
+  return doesAccountExist(AccountModel.loadByNameWithHost(nameWithDomain), res, sendNotFound)
 }
 
-async function isAccountExist (p: Bluebird<AccountModel>, res: Response, sendNotFound: boolean) {
+async function doesAccountExist (p: Bluebird<AccountModel>, res: Response, sendNotFound: boolean) {
   const account = await p
 
   if (!account) {
@@ -69,9 +62,9 @@ async function isAccountExist (p: Bluebird<AccountModel>, res: Response, sendNot
 
 export {
   isAccountIdValid,
-  isAccountIdExist,
-  isLocalAccountNameExist,
+  doesAccountIdExist,
+  doesLocalAccountNameExist,
   isAccountDescriptionValid,
-  isAccountNameWithHostExist,
+  doesAccountNameWithHostExist,
   isAccountNameValid
 }
diff --git a/server/helpers/custom-validators/activitypub/activity.ts b/server/helpers/custom-validators/activitypub/activity.ts
index b24590d9d..e0d170d9d 100644
--- a/server/helpers/custom-validators/activitypub/activity.ts
+++ b/server/helpers/custom-validators/activitypub/activity.ts
@@ -9,6 +9,7 @@ import { isViewActivityValid } from './view'
 import { exists } from '../misc'
 import { isCacheFileObjectValid } from './cache-file'
 import { isFlagActivityValid } from './flag'
+import { isPlaylistObjectValid } from './playlist'
 
 function isRootActivityValid (activity: any) {
   return Array.isArray(activity['@context']) && (
@@ -78,6 +79,7 @@ function checkCreateActivity (activity: any) {
       isViewActivityValid(activity.object) ||
       isDislikeActivityValid(activity.object) ||
       isFlagActivityValid(activity.object) ||
+      isPlaylistObjectValid(activity.object) ||
 
       isCacheFileObjectValid(activity.object) ||
       sanitizeAndCheckVideoCommentObject(activity.object) ||
@@ -89,6 +91,7 @@ function checkUpdateActivity (activity: any) {
   return isBaseActivityValid(activity, 'Update') &&
     (
       isCacheFileObjectValid(activity.object) ||
+      isPlaylistObjectValid(activity.object) ||
       sanitizeAndCheckVideoTorrentObject(activity.object) ||
       sanitizeAndCheckActorObject(activity.object)
     )
diff --git a/server/helpers/custom-validators/activitypub/actor.ts b/server/helpers/custom-validators/activitypub/actor.ts
index c05f60f14..deb331abb 100644
--- a/server/helpers/custom-validators/activitypub/actor.ts
+++ b/server/helpers/custom-validators/activitypub/actor.ts
@@ -1,5 +1,5 @@
 import * as validator from 'validator'
-import { CONSTRAINTS_FIELDS } from '../../../initializers'
+import { CONSTRAINTS_FIELDS } from '../../../initializers/constants'
 import { exists, isArray } from '../misc'
 import { truncate } from 'lodash'
 import { isActivityPubUrlValid, isBaseActivityValid, setValidAttributedTo } from './misc'
diff --git a/server/helpers/custom-validators/activitypub/cache-file.ts b/server/helpers/custom-validators/activitypub/cache-file.ts
index e2bd0c55e..21d5c53ca 100644
--- a/server/helpers/custom-validators/activitypub/cache-file.ts
+++ b/server/helpers/custom-validators/activitypub/cache-file.ts
@@ -8,9 +8,19 @@ function isCacheFileObjectValid (object: CacheFileObject) {
     object.type === 'CacheFile' &&
     isDateValid(object.expires) &&
     isActivityPubUrlValid(object.object) &&
-    isRemoteVideoUrlValid(object.url)
+    (isRemoteVideoUrlValid(object.url) || isPlaylistRedundancyUrlValid(object.url))
 }
 
+// ---------------------------------------------------------------------------
+
 export {
   isCacheFileObjectValid
 }
+
+// ---------------------------------------------------------------------------
+
+function isPlaylistRedundancyUrlValid (url: any) {
+  return url.type === 'Link' &&
+    (url.mediaType || url.mimeType) === 'application/x-mpegURL' &&
+    isActivityPubUrlValid(url.href)
+}
diff --git a/server/helpers/custom-validators/activitypub/misc.ts b/server/helpers/custom-validators/activitypub/misc.ts
index f1762d11c..5afcfbedc 100644
--- a/server/helpers/custom-validators/activitypub/misc.ts
+++ b/server/helpers/custom-validators/activitypub/misc.ts
@@ -1,5 +1,5 @@
 import * as validator from 'validator'
-import { CONSTRAINTS_FIELDS } from '../../../initializers'
+import { CONSTRAINTS_FIELDS } from '../../../initializers/constants'
 import { isTestInstance } from '../../core-utils'
 import { exists } from '../misc'
 
@@ -25,8 +25,7 @@ function isActivityPubUrlValid (url: string) {
 }
 
 function isBaseActivityValid (activity: any, type: string) {
-  return (activity['@context'] === undefined || Array.isArray(activity['@context'])) &&
-    activity.type === type &&
+  return activity.type === type &&
     isActivityPubUrlValid(activity.id) &&
     isObjectValid(activity.actor) &&
     isUrlCollectionValid(activity.to) &&
diff --git a/server/helpers/custom-validators/activitypub/playlist.ts b/server/helpers/custom-validators/activitypub/playlist.ts
new file mode 100644
index 000000000..6c7bdb193
--- /dev/null
+++ b/server/helpers/custom-validators/activitypub/playlist.ts
@@ -0,0 +1,27 @@
+import { exists, isDateValid } from '../misc'
+import { PlaylistObject } from '../../../../shared/models/activitypub/objects/playlist-object'
+import * as validator from 'validator'
+import { PlaylistElementObject } from '../../../../shared/models/activitypub/objects/playlist-element-object'
+import { isActivityPubUrlValid } from './misc'
+
+function isPlaylistObjectValid (object: PlaylistObject) {
+  return exists(object) &&
+    object.type === 'Playlist' &&
+    validator.isInt(object.totalItems + '') &&
+    isDateValid(object.published) &&
+    isDateValid(object.updated)
+}
+
+function isPlaylistElementObjectValid (object: PlaylistElementObject) {
+  return exists(object) &&
+    object.type === 'PlaylistElement' &&
+    validator.isInt(object.position + '') &&
+    isActivityPubUrlValid(object.url)
+}
+
+// ---------------------------------------------------------------------------
+
+export {
+  isPlaylistObjectValid,
+  isPlaylistElementObjectValid
+}
diff --git a/server/helpers/custom-validators/activitypub/video-comments.ts b/server/helpers/custom-validators/activitypub/video-comments.ts
index 0415db21c..26c8c4cc6 100644
--- a/server/helpers/custom-validators/activitypub/video-comments.ts
+++ b/server/helpers/custom-validators/activitypub/video-comments.ts
@@ -1,7 +1,7 @@
 import * as validator from 'validator'
-import { ACTIVITY_PUB, CONSTRAINTS_FIELDS } from '../../../initializers'
+import { ACTIVITY_PUB } from '../../../initializers/constants'
 import { exists, isArray, isDateValid } from '../misc'
-import { isActivityPubUrlValid, isBaseActivityValid } from './misc'
+import { isActivityPubUrlValid } from './misc'
 
 function sanitizeAndCheckVideoCommentObject (comment: any) {
   if (!comment || comment.type !== 'Note') return false
diff --git a/server/helpers/custom-validators/activitypub/videos.ts b/server/helpers/custom-validators/activitypub/videos.ts
index 0f34aab21..3ba6b0744 100644
--- a/server/helpers/custom-validators/activitypub/videos.ts
+++ b/server/helpers/custom-validators/activitypub/videos.ts
@@ -1,7 +1,7 @@
 import * as validator from 'validator'
-import { ACTIVITY_PUB, CONSTRAINTS_FIELDS } from '../../../initializers'
+import { ACTIVITY_PUB, CONSTRAINTS_FIELDS } from '../../../initializers/constants'
 import { peertubeTruncate } from '../../core-utils'
-import { exists, isBooleanValid, isDateValid, isUUIDValid } from '../misc'
+import { exists, isArray, isBooleanValid, isDateValid, isUUIDValid } from '../misc'
 import {
   isVideoDurationValid,
   isVideoNameValid,
@@ -12,7 +12,6 @@ import {
 } from '../videos'
 import { isActivityPubUrlValid, isBaseActivityValid, setValidAttributedTo } from './misc'
 import { VideoState } from '../../../../shared/models/videos'
-import { isVideoAbuseReasonValid } from '../video-abuses'
 
 function sanitizeAndCheckVideoTorrentUpdateActivity (activity: any) {
   return isBaseActivityValid(activity, 'Update') &&
@@ -40,6 +39,7 @@ function sanitizeAndCheckVideoTorrentObject (video: any) {
   // Default attributes
   if (!isVideoStateValid(video.state)) video.state = VideoState.PUBLISHED
   if (!isBooleanValid(video.waitTranscoding)) video.waitTranscoding = false
+  if (!isBooleanValid(video.downloadEnabled)) video.downloadEnabled = true
 
   return isActivityPubUrlValid(video.id) &&
     isVideoNameValid(video.name) &&
@@ -51,8 +51,10 @@ function sanitizeAndCheckVideoTorrentObject (video: any) {
     isVideoViewsValid(video.views) &&
     isBooleanValid(video.sensitive) &&
     isBooleanValid(video.commentsEnabled) &&
+    isBooleanValid(video.downloadEnabled) &&
     isDateValid(video.published) &&
     isDateValid(video.updated) &&
+    (!video.originallyPublishedAt || isDateValid(video.originallyPublishedAt)) &&
     (!video.content || isRemoteVideoContentValid(video.mediaType, video.content)) &&
     isRemoteVideoIconValid(video.icon) &&
     video.url.length !== 0 &&
@@ -81,6 +83,11 @@ function isRemoteVideoUrlValid (url: any) {
       ACTIVITY_PUB.URL_MIME_TYPES.MAGNET.indexOf(url.mediaType || url.mimeType) !== -1 &&
       validator.isLength(url.href, { min: 5 }) &&
       validator.isInt(url.height + '', { min: 0 })
+    ) ||
+    (
+      (url.mediaType || url.mimeType) === 'application/x-mpegURL' &&
+      isActivityPubUrlValid(url.href) &&
+      isArray(url.tag)
     )
 }
 
diff --git a/server/helpers/custom-validators/logs.ts b/server/helpers/custom-validators/logs.ts
new file mode 100644
index 000000000..30d0ce262
--- /dev/null
+++ b/server/helpers/custom-validators/logs.ts
@@ -0,0 +1,14 @@
+import { exists } from './misc'
+import { LogLevel } from '../../../shared/models/server/log-level.type'
+
+const logLevels: LogLevel[] = [ 'debug', 'info', 'warn', 'error' ]
+
+function isValidLogLevel (value: any) {
+  return exists(value) && logLevels.indexOf(value) !== -1
+}
+
+// ---------------------------------------------------------------------------
+
+export {
+  isValidLogLevel
+}
diff --git a/server/helpers/custom-validators/misc.ts b/server/helpers/custom-validators/misc.ts
index b6f0ebe6f..3a3deab0c 100644
--- a/server/helpers/custom-validators/misc.ts
+++ b/server/helpers/custom-validators/misc.ts
@@ -13,6 +13,10 @@ function isNotEmptyIntArray (value: any) {
   return Array.isArray(value) && value.every(v => validator.isInt('' + v)) && value.length !== 0
 }
 
+function isArrayOf (value: any, validator: (value: any) => boolean) {
+  return isArray(value) && value.every(v => validator(v))
+}
+
 function isDateValid (value: string) {
   return exists(value) && validator.isISO8601(value)
 }
@@ -45,12 +49,19 @@ function toValueOrNull (value: string) {
   return value
 }
 
-function toArray (value: string) {
+function toArray (value: any) {
   if (value && isArray(value) === false) return [ value ]
 
   return value
 }
 
+function toIntArray (value: any) {
+  if (!value) return []
+  if (isArray(value) === false) return [ validator.toInt(value) ]
+
+  return value.map(v => validator.toInt(v))
+}
+
 function isFileValid (
   files: { [ fieldname: string ]: Express.Multer.File[] } | Express.Multer.File[],
   mimeTypeRegex: string,
@@ -82,6 +93,7 @@ function isFileValid (
 
 export {
   exists,
+  isArrayOf,
   isNotEmptyIntArray,
   isArray,
   isIdValid,
@@ -92,5 +104,6 @@ export {
   isBooleanValid,
   toIntOrNull,
   toArray,
+  toIntArray,
   isFileValid
 }
diff --git a/server/helpers/custom-validators/servers.ts b/server/helpers/custom-validators/servers.ts
index 18c80ec8f..5c8bf0d2d 100644
--- a/server/helpers/custom-validators/servers.ts
+++ b/server/helpers/custom-validators/servers.ts
@@ -3,7 +3,7 @@ import 'express-validator'
 
 import { isArray, exists } from './misc'
 import { isTestInstance } from '../core-utils'
-import { CONSTRAINTS_FIELDS } from '../../initializers'
+import { CONSTRAINTS_FIELDS } from '../../initializers/constants'
 
 function isHostValid (host: string) {
   const isURLOptions = {
diff --git a/server/helpers/custom-validators/users.ts b/server/helpers/custom-validators/users.ts
index 80652b479..56bc10b16 100644
--- a/server/helpers/custom-validators/users.ts
+++ b/server/helpers/custom-validators/users.ts
@@ -1,8 +1,8 @@
 import 'express-validator'
 import * as validator from 'validator'
 import { UserRole } from '../../../shared'
-import { CONSTRAINTS_FIELDS, NSFW_POLICY_TYPES } from '../../initializers'
-import { exists, isFileValid, isBooleanValid } from './misc'
+import { CONSTRAINTS_FIELDS, NSFW_POLICY_TYPES } from '../../initializers/constants'
+import { exists, isBooleanValid, isFileValid } from './misc'
 import { values } from 'lodash'
 
 const USERS_CONSTRAINTS_FIELDS = CONSTRAINTS_FIELDS.USERS
@@ -54,6 +54,10 @@ function isUserAutoPlayVideoValid (value: any) {
   return isBooleanValid(value)
 }
 
+function isUserAdminFlagsValid (value: any) {
+  return exists(value) && validator.isInt('' + value)
+}
+
 function isUserBlockedValid (value: any) {
   return isBooleanValid(value)
 }
@@ -85,6 +89,7 @@ export {
   isUserVideoQuotaValid,
   isUserVideoQuotaDailyValid,
   isUserUsernameValid,
+  isUserAdminFlagsValid,
   isUserEmailVerifiedValid,
   isUserNSFWPolicyValid,
   isUserWebTorrentEnabledValid,
diff --git a/server/helpers/custom-validators/video-abuses.ts b/server/helpers/custom-validators/video-abuses.ts
index 290efb149..a61dcee1c 100644
--- a/server/helpers/custom-validators/video-abuses.ts
+++ b/server/helpers/custom-validators/video-abuses.ts
@@ -1,6 +1,6 @@
 import { Response } from 'express'
 import * as validator from 'validator'
-import { CONSTRAINTS_FIELDS, VIDEO_ABUSE_STATES } from '../../initializers'
+import { CONSTRAINTS_FIELDS, VIDEO_ABUSE_STATES } from '../../initializers/constants'
 import { exists } from './misc'
 import { VideoAbuseModel } from '../../models/video/video-abuse'
 
@@ -18,7 +18,7 @@ function isVideoAbuseStateValid (value: string) {
   return exists(value) && VIDEO_ABUSE_STATES[ value ] !== undefined
 }
 
-async function isVideoAbuseExist (abuseId: number, videoId: number, res: Response) {
+async function doesVideoAbuseExist (abuseId: number, videoId: number, res: Response) {
   const videoAbuse = await VideoAbuseModel.loadByIdAndVideoId(abuseId, videoId)
 
   if (videoAbuse === null) {
@@ -36,7 +36,7 @@ async function isVideoAbuseExist (abuseId: number, videoId: number, res: Respons
 // ---------------------------------------------------------------------------
 
 export {
-  isVideoAbuseExist,
+  doesVideoAbuseExist,
   isVideoAbuseStateValid,
   isVideoAbuseReasonValid,
   isVideoAbuseModerationCommentValid
diff --git a/server/helpers/custom-validators/video-blacklist.ts b/server/helpers/custom-validators/video-blacklist.ts
index b36b08d8b..3743f7023 100644
--- a/server/helpers/custom-validators/video-blacklist.ts
+++ b/server/helpers/custom-validators/video-blacklist.ts
@@ -1,7 +1,9 @@
 import { Response } from 'express'
 import * as validator from 'validator'
-import { CONSTRAINTS_FIELDS } from '../../initializers'
+import { exists } from './misc'
+import { CONSTRAINTS_FIELDS } from '../../initializers/constants'
 import { VideoBlacklistModel } from '../../models/video/video-blacklist'
+import { VideoBlacklistType } from '../../../shared/models/videos'
 
 const VIDEO_BLACKLIST_CONSTRAINTS_FIELDS = CONSTRAINTS_FIELDS.VIDEO_BLACKLIST
 
@@ -9,7 +11,7 @@ function isVideoBlacklistReasonValid (value: string) {
   return value === null || validator.isLength(value, VIDEO_BLACKLIST_CONSTRAINTS_FIELDS.REASON)
 }
 
-async function isVideoBlacklistExist (videoId: number, res: Response) {
+async function doesVideoBlacklistExist (videoId: number, res: Response) {
   const videoBlacklist = await VideoBlacklistModel.loadByVideoId(videoId)
 
   if (videoBlacklist === null) {
@@ -24,9 +26,14 @@ async function isVideoBlacklistExist (videoId: number, res: Response) {
   return true
 }
 
+function isVideoBlacklistTypeValid (value: any) {
+  return exists(value) && validator.isInt('' + value) && VideoBlacklistType[value] !== undefined
+}
+
 // ---------------------------------------------------------------------------
 
 export {
   isVideoBlacklistReasonValid,
-  isVideoBlacklistExist
+  isVideoBlacklistTypeValid,
+  doesVideoBlacklistExist
 }
diff --git a/server/helpers/custom-validators/video-captions.ts b/server/helpers/custom-validators/video-captions.ts
index b33d90e18..3b6569a8a 100644
--- a/server/helpers/custom-validators/video-captions.ts
+++ b/server/helpers/custom-validators/video-captions.ts
@@ -1,4 +1,4 @@
-import { CONSTRAINTS_FIELDS, MIMETYPES, VIDEO_LANGUAGES } from '../../initializers'
+import { CONSTRAINTS_FIELDS, MIMETYPES, VIDEO_LANGUAGES } from '../../initializers/constants'
 import { exists, isFileValid } from './misc'
 import { Response } from 'express'
 import { VideoModel } from '../../models/video/video'
@@ -16,7 +16,7 @@ function isVideoCaptionFile (files: { [ fieldname: string ]: Express.Multer.File
   return isFileValid(files, videoCaptionTypesRegex, field, CONSTRAINTS_FIELDS.VIDEO_CAPTIONS.CAPTION_FILE.FILE_SIZE.max)
 }
 
-async function isVideoCaptionExist (video: VideoModel, language: string, res: Response) {
+async function doesVideoCaptionExist (video: VideoModel, language: string, res: Response) {
   const videoCaption = await VideoCaptionModel.loadByVideoIdAndLanguage(video.id, language)
 
   if (!videoCaption) {
@@ -36,5 +36,5 @@ async function isVideoCaptionExist (video: VideoModel, language: string, res: Re
 export {
   isVideoCaptionFile,
   isVideoCaptionLanguageValid,
-  isVideoCaptionExist
+  doesVideoCaptionExist
 }
diff --git a/server/helpers/custom-validators/video-channels.ts b/server/helpers/custom-validators/video-channels.ts
index f13519c1d..fd56b9a70 100644
--- a/server/helpers/custom-validators/video-channels.ts
+++ b/server/helpers/custom-validators/video-channels.ts
@@ -2,7 +2,7 @@ import * as express from 'express'
 import 'express-validator'
 import 'multer'
 import * as validator from 'validator'
-import { CONFIG, CONSTRAINTS_FIELDS } from '../../initializers'
+import { CONSTRAINTS_FIELDS } from '../../initializers/constants'
 import { VideoChannelModel } from '../../models/video/video-channel'
 import { exists } from './misc'
 
@@ -20,29 +20,25 @@ function isVideoChannelSupportValid (value: string) {
   return value === null || (exists(value) && validator.isLength(value, VIDEO_CHANNELS_CONSTRAINTS_FIELDS.SUPPORT))
 }
 
-async function isLocalVideoChannelNameExist (name: string, res: express.Response) {
+async function doesLocalVideoChannelNameExist (name: string, res: express.Response) {
   const videoChannel = await VideoChannelModel.loadLocalByNameAndPopulateAccount(name)
 
   return processVideoChannelExist(videoChannel, res)
 }
 
-async function isVideoChannelIdExist (id: string, res: express.Response) {
+async function doesVideoChannelIdExist (id: number | string, res: express.Response) {
   let videoChannel: VideoChannelModel
-  if (validator.isInt(id)) {
+  if (validator.isInt('' + id)) {
     videoChannel = await VideoChannelModel.loadAndPopulateAccount(+id)
   } else { // UUID
-    videoChannel = await VideoChannelModel.loadByUUIDAndPopulateAccount(id)
+    videoChannel = await VideoChannelModel.loadByUUIDAndPopulateAccount('' + id)
   }
 
   return processVideoChannelExist(videoChannel, res)
 }
 
-async function isVideoChannelNameWithHostExist (nameWithDomain: string, res: express.Response) {
-  const [ name, host ] = nameWithDomain.split('@')
-  let videoChannel: VideoChannelModel
-
-  if (!host || host === CONFIG.WEBSERVER.HOST) videoChannel = await VideoChannelModel.loadLocalByNameAndPopulateAccount(name)
-  else videoChannel = await VideoChannelModel.loadByNameAndHostAndPopulateAccount(name, host)
+async function doesVideoChannelNameWithHostExist (nameWithDomain: string, res: express.Response) {
+  const videoChannel = await VideoChannelModel.loadByNameWithHostAndPopulateAccount(nameWithDomain)
 
   return processVideoChannelExist(videoChannel, res)
 }
@@ -50,12 +46,12 @@ async function isVideoChannelNameWithHostExist (nameWithDomain: string, res: exp
 // ---------------------------------------------------------------------------
 
 export {
-  isVideoChannelNameWithHostExist,
-  isLocalVideoChannelNameExist,
+  doesVideoChannelNameWithHostExist,
+  doesLocalVideoChannelNameExist,
   isVideoChannelDescriptionValid,
   isVideoChannelNameValid,
   isVideoChannelSupportValid,
-  isVideoChannelIdExist
+  doesVideoChannelIdExist
 }
 
 function processVideoChannelExist (videoChannel: VideoChannelModel, res: express.Response) {
diff --git a/server/helpers/custom-validators/video-comments.ts b/server/helpers/custom-validators/video-comments.ts
index 2b3f66063..0707e2af2 100644
--- a/server/helpers/custom-validators/video-comments.ts
+++ b/server/helpers/custom-validators/video-comments.ts
@@ -1,7 +1,7 @@
 import 'express-validator'
 import 'multer'
 import * as validator from 'validator'
-import { CONSTRAINTS_FIELDS } from '../../initializers'
+import { CONSTRAINTS_FIELDS } from '../../initializers/constants'
 
 const VIDEO_COMMENTS_CONSTRAINTS_FIELDS = CONSTRAINTS_FIELDS.VIDEO_COMMENTS
 
diff --git a/server/helpers/custom-validators/video-imports.ts b/server/helpers/custom-validators/video-imports.ts
index ce9e9193c..f4235e2fa 100644
--- a/server/helpers/custom-validators/video-imports.ts
+++ b/server/helpers/custom-validators/video-imports.ts
@@ -1,7 +1,7 @@
 import 'express-validator'
 import 'multer'
 import * as validator from 'validator'
-import { CONSTRAINTS_FIELDS, MIMETYPES, VIDEO_IMPORT_STATES } from '../../initializers'
+import { CONSTRAINTS_FIELDS, MIMETYPES, VIDEO_IMPORT_STATES } from '../../initializers/constants'
 import { exists, isFileValid } from './misc'
 import * as express from 'express'
 import { VideoImportModel } from '../../models/video/video-import'
@@ -30,7 +30,7 @@ function isVideoImportTorrentFile (files: { [ fieldname: string ]: Express.Multe
   return isFileValid(files, videoTorrentImportRegex, 'torrentfile', CONSTRAINTS_FIELDS.VIDEO_IMPORTS.TORRENT_FILE.FILE_SIZE.max, true)
 }
 
-async function isVideoImportExist (id: number, res: express.Response) {
+async function doesVideoImportExist (id: number, res: express.Response) {
   const videoImport = await VideoImportModel.loadAndPopulateVideo(id)
 
   if (!videoImport) {
@@ -50,6 +50,6 @@ async function isVideoImportExist (id: number, res: express.Response) {
 export {
   isVideoImportStateValid,
   isVideoImportTargetUrlValid,
-  isVideoImportExist,
+  doesVideoImportExist,
   isVideoImportTorrentFile
 }
diff --git a/server/helpers/custom-validators/video-playlists.ts b/server/helpers/custom-validators/video-playlists.ts
new file mode 100644
index 000000000..2fe426560
--- /dev/null
+++ b/server/helpers/custom-validators/video-playlists.ts
@@ -0,0 +1,55 @@
+import { exists } from './misc'
+import * as validator from 'validator'
+import { CONSTRAINTS_FIELDS, VIDEO_PLAYLIST_PRIVACIES, VIDEO_PLAYLIST_TYPES } from '../../initializers/constants'
+import * as express from 'express'
+import { VideoPlaylistModel } from '../../models/video/video-playlist'
+
+const PLAYLISTS_CONSTRAINT_FIELDS = CONSTRAINTS_FIELDS.VIDEO_PLAYLISTS
+
+function isVideoPlaylistNameValid (value: any) {
+  return exists(value) && validator.isLength(value, PLAYLISTS_CONSTRAINT_FIELDS.NAME)
+}
+
+function isVideoPlaylistDescriptionValid (value: any) {
+  return value === null || (exists(value) && validator.isLength(value, PLAYLISTS_CONSTRAINT_FIELDS.DESCRIPTION))
+}
+
+function isVideoPlaylistPrivacyValid (value: number) {
+  return validator.isInt(value + '') && VIDEO_PLAYLIST_PRIVACIES[ value ] !== undefined
+}
+
+function isVideoPlaylistTimestampValid (value: any) {
+  return value === null || (exists(value) && validator.isInt('' + value, { min: 0 }))
+}
+
+function isVideoPlaylistTypeValid (value: any) {
+  return exists(value) && VIDEO_PLAYLIST_TYPES[ value ] !== undefined
+}
+
+async function doesVideoPlaylistExist (id: number | string, res: express.Response, fetchType: 'summary' | 'all' = 'summary') {
+  const videoPlaylist = fetchType === 'summary'
+    ? await VideoPlaylistModel.loadWithAccountAndChannelSummary(id, undefined)
+    : await VideoPlaylistModel.loadWithAccountAndChannel(id, undefined)
+
+  if (!videoPlaylist) {
+    res.status(404)
+       .json({ error: 'Video playlist not found' })
+       .end()
+
+    return false
+  }
+
+  res.locals.videoPlaylist = videoPlaylist
+  return true
+}
+
+// ---------------------------------------------------------------------------
+
+export {
+  doesVideoPlaylistExist,
+  isVideoPlaylistNameValid,
+  isVideoPlaylistDescriptionValid,
+  isVideoPlaylistPrivacyValid,
+  isVideoPlaylistTimestampValid,
+  isVideoPlaylistTypeValid
+}
diff --git a/server/helpers/custom-validators/video-rates.ts b/server/helpers/custom-validators/video-rates.ts
new file mode 100644
index 000000000..f2b6f7cae
--- /dev/null
+++ b/server/helpers/custom-validators/video-rates.ts
@@ -0,0 +1,5 @@
+function isRatingValid (value: any) {
+  return value === 'like' || value === 'dislike'
+}
+
+export { isRatingValid }
diff --git a/server/helpers/custom-validators/videos.ts b/server/helpers/custom-validators/videos.ts
index 95e256b8f..214db17a1 100644
--- a/server/helpers/custom-validators/videos.ts
+++ b/server/helpers/custom-validators/videos.ts
@@ -5,15 +5,16 @@ import 'multer'
 import * as validator from 'validator'
 import { UserRight, VideoFilter, VideoPrivacy, VideoRateType } from '../../../shared'
 import {
-  CONSTRAINTS_FIELDS, MIMETYPES,
+  CONSTRAINTS_FIELDS,
+  MIMETYPES,
   VIDEO_CATEGORIES,
   VIDEO_LICENCES,
   VIDEO_PRIVACIES,
   VIDEO_RATE_TYPES,
   VIDEO_STATES
-} from '../../initializers'
+} from '../../initializers/constants'
 import { VideoModel } from '../../models/video/video'
-import { exists, isArray, isFileValid } from './misc'
+import { exists, isArray, isDateValid, isFileValid } from './misc'
 import { VideoChannelModel } from '../../models/video/video-channel'
 import { UserModel } from '../../models/account/user'
 import * as magnetUtil from 'magnet-uri'
@@ -115,6 +116,10 @@ function isScheduleVideoUpdatePrivacyValid (value: number) {
     )
 }
 
+function isVideoOriginallyPublishedAtValid (value: string | null) {
+  return value === null || isDateValid(value)
+}
+
 function isVideoFileInfoHashValid (value: string | null | undefined) {
   return exists(value) && validator.isLength(value, VIDEOS_CONSTRAINTS_FIELDS.INFO_HASH)
 }
@@ -161,7 +166,7 @@ function checkUserCanManageVideo (user: UserModel, video: VideoModel, right: Use
   return true
 }
 
-async function isVideoExist (id: string, res: Response, fetchType: VideoFetchType = 'all') {
+async function doesVideoExist (id: number | string, res: Response, fetchType: VideoFetchType = 'all') {
   const userId = res.locals.oauth ? res.locals.oauth.token.User.id : undefined
 
   const video = await fetchVideo(id, fetchType, userId)
@@ -178,7 +183,7 @@ async function isVideoExist (id: string, res: Response, fetchType: VideoFetchTyp
   return true
 }
 
-async function isVideoChannelOfAccountExist (channelId: number, user: UserModel, res: Response) {
+async function doesVideoChannelOfAccountExist (channelId: number, user: UserModel, res: Response) {
   if (user.hasRight(UserRight.UPDATE_ANY_VIDEO) === true) {
     const videoChannel = await VideoChannelModel.loadAndPopulateAccount(channelId)
     if (videoChannel === null) {
@@ -220,6 +225,7 @@ export {
   isVideoTagsValid,
   isVideoFPSResolutionValid,
   isScheduleVideoUpdatePrivacyValid,
+  isVideoOriginallyPublishedAtValid,
   isVideoFile,
   isVideoMagnetUriValid,
   isVideoStateValid,
@@ -231,9 +237,9 @@ export {
   isVideoPrivacyValid,
   isVideoFileResolutionValid,
   isVideoFileSizeValid,
-  isVideoExist,
+  doesVideoExist,
   isVideoImage,
-  isVideoChannelOfAccountExist,
+  doesVideoChannelOfAccountExist,
   isVideoSupportValid,
   isVideoFilterValid
 }
diff --git a/server/helpers/custom-validators/webfinger.ts b/server/helpers/custom-validators/webfinger.ts
index 80a7e4a9d..dd914341e 100644
--- a/server/helpers/custom-validators/webfinger.ts
+++ b/server/helpers/custom-validators/webfinger.ts
@@ -1,4 +1,4 @@
-import { CONFIG, REMOTE_SCHEME } from '../../initializers'
+import { REMOTE_SCHEME, WEBSERVER } from '../../initializers/constants'
 import { sanitizeHost } from '../core-utils'
 import { exists } from './misc'
 
@@ -11,7 +11,7 @@ function isWebfingerLocalResourceValid (value: string) {
   if (actorParts.length !== 2) return false
 
   const host = actorParts[1]
-  return sanitizeHost(host, REMOTE_SCHEME.HTTP) === CONFIG.WEBSERVER.HOST
+  return sanitizeHost(host, REMOTE_SCHEME.HTTP) === WEBSERVER.HOST
 }
 
 // ---------------------------------------------------------------------------
diff --git a/server/helpers/database-utils.ts b/server/helpers/database-utils.ts
index 1005d2cf1..39c74b2fd 100644
--- a/server/helpers/database-utils.ts
+++ b/server/helpers/database-utils.ts
@@ -62,14 +62,13 @@ function updateInstanceWithAnother <T extends Model<T>> (instanceToUpdate: Model
   const obj = baseInstance.toJSON()
 
   for (const key of Object.keys(obj)) {
-    instanceToUpdate.set(key, obj[key])
+    instanceToUpdate[key] = obj[key]
   }
 }
 
 function resetSequelizeInstance (instance: Model<any>, savedFields: object) {
   Object.keys(savedFields).forEach(key => {
-    const value = savedFields[key]
-    instance.set(key, value)
+    instance[key] = savedFields[key]
   })
 }
 
diff --git a/server/helpers/express-utils.ts b/server/helpers/express-utils.ts
index 9a72ee96d..e0a1d56a5 100644
--- a/server/helpers/express-utils.ts
+++ b/server/helpers/express-utils.ts
@@ -1,11 +1,11 @@
 import * as express from 'express'
 import * as multer from 'multer'
-import { CONFIG, REMOTE_SCHEME } from '../initializers'
+import { REMOTE_SCHEME } from '../initializers/constants'
 import { logger } from './logger'
 import { deleteFileAsync, generateRandomString } from './utils'
 import { extname } from 'path'
 import { isArray } from './custom-validators/misc'
-import { UserModel } from '../models/account/user'
+import { CONFIG } from '../initializers/config'
 
 function buildNSFWFilter (res?: express.Response, paramNSFW?: string) {
   if (paramNSFW === 'true') return true
@@ -13,7 +13,7 @@ function buildNSFWFilter (res?: express.Response, paramNSFW?: string) {
   if (paramNSFW === 'both') return undefined
 
   if (res && res.locals.oauth) {
-    const user: UserModel = res.locals.oauth.token.User
+    const user = res.locals.oauth.token.User
 
     // User does not want NSFW videos
     if (user.nsfwPolicy === 'do_not_list') return false
@@ -59,7 +59,7 @@ function getHostWithPort (host: string) {
   return host
 }
 
-function badRequest (req: express.Request, res: express.Response, next: express.NextFunction) {
+function badRequest (req: express.Request, res: express.Response) {
   return res.type('json').status(400).end()
 }
 
@@ -100,7 +100,7 @@ function createReqFiles (
 }
 
 function isUserAbleToSearchRemoteURI (res: express.Response) {
-  const user: UserModel = res.locals.oauth ? res.locals.oauth.token.User : undefined
+  const user = res.locals.oauth ? res.locals.oauth.token.User : undefined
 
   return CONFIG.SEARCH.REMOTE_URI.ANONYMOUS === true ||
     (CONFIG.SEARCH.REMOTE_URI.USERS === true && user !== undefined)
diff --git a/server/helpers/ffmpeg-utils.ts b/server/helpers/ffmpeg-utils.ts
index 132f4690e..76b744de8 100644
--- a/server/helpers/ffmpeg-utils.ts
+++ b/server/helpers/ffmpeg-utils.ts
@@ -1,11 +1,12 @@
 import * as ffmpeg from 'fluent-ffmpeg'
-import { join } from 'path'
+import { dirname, join } from 'path'
 import { getTargetBitrate, VideoResolution } from '../../shared/models/videos'
-import { CONFIG, FFMPEG_NICE, VIDEO_TRANSCODING_FPS } from '../initializers/constants'
+import { FFMPEG_NICE, VIDEO_TRANSCODING_FPS } from '../initializers/constants'
 import { processImage } from './image-utils'
 import { logger } from './logger'
 import { checkFFmpegEncoders } from '../initializers/checker-before-init'
-import { remove } from 'fs-extra'
+import { readFile, remove, writeFile } from 'fs-extra'
+import { CONFIG } from '../initializers/config'
 
 function computeResolutionsToTranscode (videoFileHeight: number) {
   const resolutionsEnabled: number[] = []
@@ -29,12 +30,21 @@ function computeResolutionsToTranscode (videoFileHeight: number) {
   return resolutionsEnabled
 }
 
-async function getVideoFileResolution (path: string) {
+async function getVideoFileSize (path: string) {
   const videoStream = await getVideoFileStream(path)
 
   return {
-    videoFileResolution: Math.min(videoStream.height, videoStream.width),
-    isPortraitMode: videoStream.height > videoStream.width
+    width: videoStream.width,
+    height: videoStream.height
+  }
+}
+
+async function getVideoFileResolution (path: string) {
+  const size = await getVideoFileSize(path)
+
+  return {
+    videoFileResolution: Math.min(size.height, size.width),
+    isPortraitMode: size.height > size.width
   }
 }
 
@@ -95,7 +105,7 @@ async function generateImageFromVideoFile (fromPath: string, folder: string, ima
     })
 
     const destination = join(folder, imageName)
-    await processImage({ path: pendingImagePath }, destination, size)
+    await processImage(pendingImagePath, destination, size)
   } catch (err) {
     logger.error('Cannot generate image from video %s.', fromPath, { err })
 
@@ -110,52 +120,41 @@ async function generateImageFromVideoFile (fromPath: string, folder: string, ima
 type TranscodeOptions = {
   inputPath: string
   outputPath: string
-  resolution?: VideoResolution
+  resolution: VideoResolution
   isPortraitMode?: boolean
+
+  hlsPlaylist?: {
+    videoFilename: string
+  }
 }
 
 function transcode (options: TranscodeOptions) {
   return new Promise<void>(async (res, rej) => {
     try {
-      let fps = await getVideoFileFPS(options.inputPath)
-      // On small/medium resolutions, limit FPS
-      if (
-        options.resolution !== undefined &&
-        options.resolution < VIDEO_TRANSCODING_FPS.KEEP_ORIGIN_FPS_RESOLUTION_MIN &&
-        fps > VIDEO_TRANSCODING_FPS.AVERAGE
-      ) {
-        fps = VIDEO_TRANSCODING_FPS.AVERAGE
-      }
-
       let command = ffmpeg(options.inputPath, { niceness: FFMPEG_NICE.TRANSCODING })
         .output(options.outputPath)
-      command = await presetH264(command, options.resolution, fps)
+
+      if (options.hlsPlaylist) {
+        command = await buildHLSCommand(command, options)
+      } else {
+        command = await buildx264Command(command, options)
+      }
 
       if (CONFIG.TRANSCODING.THREADS > 0) {
         // if we don't set any threads ffmpeg will chose automatically
         command = command.outputOption('-threads ' + CONFIG.TRANSCODING.THREADS)
       }
 
-      if (options.resolution !== undefined) {
-        // '?x720' or '720x?' for example
-        const size = options.isPortraitMode === true ? `${options.resolution}x?` : `?x${options.resolution}`
-        command = command.size(size)
-      }
-
-      if (fps) {
-        // Hard FPS limits
-        if (fps > VIDEO_TRANSCODING_FPS.MAX) fps = VIDEO_TRANSCODING_FPS.MAX
-        else if (fps < VIDEO_TRANSCODING_FPS.MIN) fps = VIDEO_TRANSCODING_FPS.MIN
-
-        command = command.withFPS(fps)
-      }
-
       command
         .on('error', (err, stdout, stderr) => {
           logger.error('Error in transcoding job.', { stdout, stderr })
           return rej(err)
         })
-        .on('end', res)
+        .on('end', () => {
+          return onTranscodingSuccess(options)
+            .then(() => res())
+            .catch(err => rej(err))
+        })
         .run()
     } catch (err) {
       return rej(err)
@@ -166,6 +165,7 @@ function transcode (options: TranscodeOptions) {
 // ---------------------------------------------------------------------------
 
 export {
+  getVideoFileSize,
   getVideoFileResolution,
   getDurationFromVideoFile,
   generateImageFromVideoFile,
@@ -178,6 +178,71 @@ export {
 
 // ---------------------------------------------------------------------------
 
+async function buildx264Command (command: ffmpeg.FfmpegCommand, options: TranscodeOptions) {
+  let fps = await getVideoFileFPS(options.inputPath)
+  // On small/medium resolutions, limit FPS
+  if (
+    options.resolution !== undefined &&
+    options.resolution < VIDEO_TRANSCODING_FPS.KEEP_ORIGIN_FPS_RESOLUTION_MIN &&
+    fps > VIDEO_TRANSCODING_FPS.AVERAGE
+  ) {
+    fps = VIDEO_TRANSCODING_FPS.AVERAGE
+  }
+
+  command = await presetH264(command, options.resolution, fps)
+
+  if (options.resolution !== undefined) {
+    // '?x720' or '720x?' for example
+    const size = options.isPortraitMode === true ? `${options.resolution}x?` : `?x${options.resolution}`
+    command = command.size(size)
+  }
+
+  if (fps) {
+    // Hard FPS limits
+    if (fps > VIDEO_TRANSCODING_FPS.MAX) fps = VIDEO_TRANSCODING_FPS.MAX
+    else if (fps < VIDEO_TRANSCODING_FPS.MIN) fps = VIDEO_TRANSCODING_FPS.MIN
+
+    command = command.withFPS(fps)
+  }
+
+  return command
+}
+
+async function buildHLSCommand (command: ffmpeg.FfmpegCommand, options: TranscodeOptions) {
+  const videoPath = getHLSVideoPath(options)
+
+  command = await presetCopy(command)
+
+  command = command.outputOption('-hls_time 4')
+                   .outputOption('-hls_list_size 0')
+                   .outputOption('-hls_playlist_type vod')
+                   .outputOption('-hls_segment_filename ' + videoPath)
+                   .outputOption('-hls_segment_type fmp4')
+                   .outputOption('-f hls')
+                   .outputOption('-hls_flags single_file')
+
+  return command
+}
+
+function getHLSVideoPath (options: TranscodeOptions) {
+  return `${dirname(options.outputPath)}/${options.hlsPlaylist.videoFilename}`
+}
+
+async function onTranscodingSuccess (options: TranscodeOptions) {
+  if (!options.hlsPlaylist) return
+
+  // Fix wrong mapping with some ffmpeg versions
+  const fileContent = await readFile(options.outputPath)
+
+  const videoFileName = options.hlsPlaylist.videoFilename
+  const videoFilePath = getHLSVideoPath(options)
+
+  const newContent = fileContent.toString()
+                                .replace(`#EXT-X-MAP:URI="${videoFilePath}",`, `#EXT-X-MAP:URI="${videoFileName}",`)
+
+  await writeFile(options.outputPath, newContent)
+}
+
 function getVideoFileStream (path: string) {
   return new Promise<any>((res, rej) => {
     ffmpeg.ffprobe(path, (err, metadata) => {
@@ -348,3 +413,10 @@ async function presetH264 (command: ffmpeg.FfmpegCommand, resolution: VideoResol
 
   return localCommand
 }
+
+async function presetCopy (command: ffmpeg.FfmpegCommand): Promise<ffmpeg.FfmpegCommand> {
+  return command
+    .format('mp4')
+    .videoCodec('copy')
+    .audioCodec('copy')
+}
diff --git a/server/helpers/image-utils.ts b/server/helpers/image-utils.ts
index e43ea3f1d..bd81aa3ba 100644
--- a/server/helpers/image-utils.ts
+++ b/server/helpers/image-utils.ts
@@ -4,18 +4,19 @@ import { readFile, remove } from 'fs-extra'
 import { logger } from './logger'
 
 async function processImage (
-  physicalFile: { path: string },
+  path: string,
   destination: string,
-  newSize: { width: number, height: number }
+  newSize: { width: number, height: number },
+  keepOriginal = false
 ) {
-  if (physicalFile.path === destination) {
+  if (path === destination) {
     throw new Error('Sharp needs an input path different that the output path.')
   }
 
-  logger.debug('Processing image %s to %s.', physicalFile.path, destination)
+  logger.debug('Processing image %s to %s.', path, destination)
 
   // Avoid sharp cache
-  const buf = await readFile(physicalFile.path)
+  const buf = await readFile(path)
   const sharpInstance = sharp(buf)
 
   await remove(destination)
@@ -24,7 +25,7 @@ async function processImage (
     .resize(newSize.width, newSize.height)
     .toFile(destination)
 
-  await remove(physicalFile.path)
+  if (keepOriginal !== true) await remove(path)
 }
 
 // ---------------------------------------------------------------------------
diff --git a/server/helpers/logger.ts b/server/helpers/logger.ts
index 203e637a8..734523b01 100644
--- a/server/helpers/logger.ts
+++ b/server/helpers/logger.ts
@@ -2,11 +2,13 @@
 import { mkdirpSync } from 'fs-extra'
 import * as path from 'path'
 import * as winston from 'winston'
-import { CONFIG } from '../initializers'
+import { CONFIG } from '../initializers/config'
+import { omit } from 'lodash'
 
 const label = CONFIG.WEBSERVER.HOSTNAME + ':' + CONFIG.WEBSERVER.PORT
 
 // Create the directory if it does not exist
+// FIXME: use async
 mkdirpSync(CONFIG.STORAGE.LOG_DIR)
 
 function loggerReplacer (key: string, value: any) {
@@ -22,13 +24,10 @@ function loggerReplacer (key: string, value: any) {
 }
 
 const consoleLoggerFormat = winston.format.printf(info => {
-  const obj = {
-    meta: info.meta,
-    err: info.err,
-    sql: info.sql
-  }
+  const obj = omit(info, 'label', 'timestamp', 'level', 'message')
 
   let additionalInfos = JSON.stringify(obj, loggerReplacer, 2)
+
   if (additionalInfos === undefined || additionalInfos === '{}') additionalInfos = ''
   else additionalInfos = ' ' + additionalInfos
 
@@ -57,7 +56,7 @@ const logger = winston.createLogger({
       filename: path.join(CONFIG.STORAGE.LOG_DIR, 'peertube.log'),
       handleExceptions: true,
       maxsize: 1024 * 1024 * 12,
-      maxFiles: 5,
+      maxFiles: 20,
       format: winston.format.combine(
         winston.format.timestamp(),
         jsonLoggerFormat
diff --git a/server/helpers/peertube-crypto.ts b/server/helpers/peertube-crypto.ts
index ab9ec077e..9148df2eb 100644
--- a/server/helpers/peertube-crypto.ts
+++ b/server/helpers/peertube-crypto.ts
@@ -1,5 +1,5 @@
 import { Request } from 'express'
-import { BCRYPT_SALT_SIZE, HTTP_SIGNATURE, PRIVATE_RSA_KEY_SIZE } from '../initializers'
+import { BCRYPT_SALT_SIZE, HTTP_SIGNATURE, PRIVATE_RSA_KEY_SIZE } from '../initializers/constants'
 import { ActorModel } from '../models/activitypub/actor'
 import { bcryptComparePromise, bcryptGenSaltPromise, bcryptHashPromise, createPrivateKey, getPublicKey, sha256 } from './core-utils'
 import { jsig, jsonld } from './custom-jsonld-signature'
diff --git a/server/helpers/requests.ts b/server/helpers/requests.ts
index 3fc776f1a..2e30c94a1 100644
--- a/server/helpers/requests.ts
+++ b/server/helpers/requests.ts
@@ -1,13 +1,16 @@
 import * as Bluebird from 'bluebird'
-import { createWriteStream } from 'fs-extra'
+import { createWriteStream, remove } from 'fs-extra'
 import * as request from 'request'
-import { ACTIVITY_PUB, CONFIG } from '../initializers'
+import { ACTIVITY_PUB } from '../initializers/constants'
 import { processImage } from './image-utils'
 import { join } from 'path'
+import { logger } from './logger'
+import { CONFIG } from '../initializers/config'
 
 function doRequest <T> (
-  requestOptions: request.CoreOptions & request.UriOptions & { activityPub?: boolean }
-): Bluebird<{ response: request.RequestResponse, body: any }> {
+  requestOptions: request.CoreOptions & request.UriOptions & { activityPub?: boolean },
+  bodyKBLimit = 1000 // 1MB
+): Bluebird<{ response: request.RequestResponse, body: T }> {
   if (requestOptions.activityPub === true) {
     if (!Array.isArray(requestOptions.headers)) requestOptions.headers = {}
     requestOptions.headers['accept'] = ACTIVITY_PUB.ACCEPT_HEADER
@@ -15,16 +18,29 @@ function doRequest <T> (
 
   return new Bluebird<{ response: request.RequestResponse, body: T }>((res, rej) => {
     request(requestOptions, (err, response, body) => err ? rej(err) : res({ response, body }))
+      .on('data', onRequestDataLengthCheck(bodyKBLimit))
   })
 }
 
-function doRequestAndSaveToFile (requestOptions: request.CoreOptions & request.UriOptions, destPath: string) {
+function doRequestAndSaveToFile (
+  requestOptions: request.CoreOptions & request.UriOptions,
+  destPath: string,
+  bodyKBLimit = 10000 // 10MB
+) {
   return new Bluebird<void>((res, rej) => {
     const file = createWriteStream(destPath)
     file.on('finish', () => res())
 
     request(requestOptions)
-      .on('error', err => rej(err))
+      .on('data', onRequestDataLengthCheck(bodyKBLimit))
+      .on('error', err => {
+        file.close()
+
+        remove(destPath)
+          .catch(err => logger.error('Cannot remove %s after request failure.', destPath, { err }))
+
+        return rej(err)
+      })
       .pipe(file)
   })
 }
@@ -34,7 +50,14 @@ async function downloadImage (url: string, destDir: string, destName: string, si
   await doRequestAndSaveToFile({ method: 'GET', uri: url }, tmpPath)
 
   const destPath = join(destDir, destName)
-  await processImage({ path: tmpPath }, destPath, size)
+
+  try {
+    await processImage(tmpPath, destPath, size)
+  } catch (err) {
+    await remove(tmpPath)
+
+    throw err
+  }
 }
 
 // ---------------------------------------------------------------------------
@@ -44,3 +67,21 @@ export {
   doRequestAndSaveToFile,
   downloadImage
 }
+
+// ---------------------------------------------------------------------------
+
+// Thanks to https://github.com/request/request/issues/2470#issuecomment-268929907 <3
+function onRequestDataLengthCheck (bodyKBLimit: number) {
+  let bufferLength = 0
+  const bytesLimit = bodyKBLimit * 1000
+
+  return function (chunk) {
+    bufferLength += chunk.length
+    if (bufferLength > bytesLimit) {
+      this.abort()
+
+      const error = new Error(`Response was too large - aborted after ${bytesLimit} bytes.`)
+      this.emit('error', error)
+    }
+  }
+}
diff --git a/server/helpers/signup.ts b/server/helpers/signup.ts
index cdce7989d..5eb56b3cf 100644
--- a/server/helpers/signup.ts
+++ b/server/helpers/signup.ts
@@ -1,6 +1,7 @@
-import { CONFIG } from '../initializers'
 import { UserModel } from '../models/account/user'
 import * as ipaddr from 'ipaddr.js'
+import { CONFIG } from '../initializers/config'
+
 const isCidr = require('is-cidr')
 
 async function isSignupAllowed () {
diff --git a/server/helpers/utils.ts b/server/helpers/utils.ts
index 3c3406e38..94ceb15e0 100644
--- a/server/helpers/utils.ts
+++ b/server/helpers/utils.ts
@@ -1,5 +1,4 @@
 import { ResultList } from '../../shared'
-import { CONFIG } from '../initializers'
 import { ApplicationModel } from '../models/application/application'
 import { execPromise, execPromise2, pseudoRandomBytesPromise, sha256 } from './core-utils'
 import { logger } from './logger'
@@ -7,7 +6,7 @@ import { join } from 'path'
 import { Instance as ParseTorrent } from 'parse-torrent'
 import { remove } from 'fs-extra'
 import * as memoizee from 'memoizee'
-import { isArray } from './custom-validators/misc'
+import { CONFIG } from '../initializers/config'
 
 function deleteFileAsync (path: string) {
   remove(path)
diff --git a/server/helpers/video.ts b/server/helpers/video.ts
index 1bd21467d..c90fe06c7 100644
--- a/server/helpers/video.ts
+++ b/server/helpers/video.ts
@@ -1,10 +1,12 @@
 import { VideoModel } from '../models/video/video'
 
-type VideoFetchType = 'all' | 'only-video' | 'id' | 'none'
+type VideoFetchType = 'all' | 'only-video' | 'only-video-with-rights' | 'id' | 'none'
 
 function fetchVideo (id: number | string, fetchType: VideoFetchType, userId?: number) {
   if (fetchType === 'all') return VideoModel.loadAndPopulateAccountAndServerAndTags(id, undefined, userId)
 
+  if (fetchType === 'only-video-with-rights') return VideoModel.loadWithRights(id)
+
   if (fetchType === 'only-video') return VideoModel.load(id)
 
   if (fetchType === 'id' || fetchType === 'none') return VideoModel.loadOnlyId(id)
diff --git a/server/helpers/webfinger.ts b/server/helpers/webfinger.ts
index 156376943..049808846 100644
--- a/server/helpers/webfinger.ts
+++ b/server/helpers/webfinger.ts
@@ -3,7 +3,7 @@ import { WebFingerData } from '../../shared'
 import { ActorModel } from '../models/activitypub/actor'
 import { isTestInstance } from './core-utils'
 import { isActivityPubUrlValid } from './custom-validators/activitypub/misc'
-import { CONFIG } from '../initializers'
+import { WEBSERVER } from '../initializers/constants'
 
 const webfinger = new WebFinger({
   webfist_fallback: false,
@@ -19,7 +19,7 @@ async function loadActorUrlOrGetFromWebfinger (uriArg: string) {
   const [ name, host ] = uri.split('@')
   let actor: ActorModel
 
-  if (host === CONFIG.WEBSERVER.HOST) {
+  if (host === WEBSERVER.HOST) {
     actor = await ActorModel.loadLocalByName(name)
   } else {
     actor = await ActorModel.loadByNameAndHost(name, host)
diff --git a/server/helpers/webtorrent.ts b/server/helpers/webtorrent.ts
index 3c9a0b96a..14dfe0d28 100644
--- a/server/helpers/webtorrent.ts
+++ b/server/helpers/webtorrent.ts
@@ -2,7 +2,7 @@ import { logger } from './logger'
 import { generateVideoImportTmpPath } from './utils'
 import * as WebTorrent from 'webtorrent'
 import { createWriteStream, ensureDir, remove } from 'fs-extra'
-import { CONFIG } from '../initializers'
+import { CONFIG } from '../initializers/config'
 import { dirname, join } from 'path'
 
 async function downloadWebTorrentVideo (target: { magnetUri: string, torrentName?: string }, timeout: number) {
diff --git a/server/helpers/youtube-dl.ts b/server/helpers/youtube-dl.ts
index b74351b42..b3079370f 100644
--- a/server/helpers/youtube-dl.ts
+++ b/server/helpers/youtube-dl.ts
@@ -1,5 +1,5 @@
 import { truncate } from 'lodash'
-import { CONSTRAINTS_FIELDS, VIDEO_CATEGORIES } from '../initializers'
+import { CONSTRAINTS_FIELDS, VIDEO_CATEGORIES } from '../initializers/constants'
 import { logger } from './logger'
 import { generateVideoImportTmpPath } from './utils'
 import { join } from 'path'
@@ -16,6 +16,7 @@ export type YoutubeDLInfo = {
   nsfw?: boolean
   tags?: string[]
   thumbnailUrl?: string
+  originallyPublishedAt?: Date
 }
 
 const processOptions = {
@@ -47,6 +48,11 @@ function downloadYoutubeDLVideo (url: string, timeout: number) {
 
   const options = [ '-f', 'bestvideo[ext=mp4]+bestaudio[ext=m4a]/best', '-o', path ]
 
+  if (process.env.FFMPEG_PATH) {
+    options.push('--ffmpeg-location')
+    options.push(process.env.FFMPEG_PATH)
+  }
+
   return new Promise<string>(async (res, rej) => {
     const youtubeDL = await safeGetYoutubeDL()
     youtubeDL.exec(url, options, processOptions, err => {
@@ -142,13 +148,33 @@ async function safeGetYoutubeDL () {
   return youtubeDL
 }
 
+function buildOriginallyPublishedAt (obj: any) {
+  let originallyPublishedAt: Date = null
+
+  const uploadDateMatcher = /^(\d{4})(\d{2})(\d{2})$/.exec(obj.upload_date)
+  if (uploadDateMatcher) {
+    originallyPublishedAt = new Date()
+    originallyPublishedAt.setHours(0, 0, 0, 0)
+
+    const year = parseInt(uploadDateMatcher[1], 10)
+    // Month starts from 0
+    const month = parseInt(uploadDateMatcher[2], 10) - 1
+    const day = parseInt(uploadDateMatcher[3], 10)
+
+    originallyPublishedAt.setFullYear(year, month, day)
+  }
+
+  return originallyPublishedAt
+}
+
 // ---------------------------------------------------------------------------
 
 export {
   updateYoutubeDLBinary,
   downloadYoutubeDLVideo,
   getYoutubeDLInfo,
-  safeGetYoutubeDL
+  safeGetYoutubeDL,
+  buildOriginallyPublishedAt
 }
 
 // ---------------------------------------------------------------------------
@@ -180,7 +206,8 @@ function buildVideoInfo (obj: any) {
     licence: getLicence(obj.license),
     nsfw: isNSFW(obj),
     tags: getTags(obj.tags),
-    thumbnailUrl: obj.thumbnail || undefined
+    thumbnailUrl: obj.thumbnail || undefined,
+    originallyPublishedAt: buildOriginallyPublishedAt(obj)
   }
 }
 
diff --git a/server/initializers/checker-after-init.ts b/server/initializers/checker-after-init.ts
index 955d55206..db3115085 100644
--- a/server/initializers/checker-after-init.ts
+++ b/server/initializers/checker-after-init.ts
@@ -4,19 +4,20 @@ import { UserModel } from '../models/account/user'
 import { ApplicationModel } from '../models/application/application'
 import { OAuthClientModel } from '../models/oauth/oauth-client'
 import { parse } from 'url'
-import { CONFIG } from './constants'
+import { CONFIG } from './config'
 import { logger } from '../helpers/logger'
 import { getServerActor } from '../helpers/utils'
 import { RecentlyAddedStrategy } from '../../shared/models/redundancy'
 import { isArray } from '../helpers/custom-validators/misc'
 import { uniq } from 'lodash'
 import { Emailer } from '../lib/emailer'
+import { WEBSERVER } from './constants'
 
 async function checkActivityPubUrls () {
   const actor = await getServerActor()
 
   const parsed = parse(actor.url)
-  if (CONFIG.WEBSERVER.HOST !== parsed.host) {
+  if (WEBSERVER.HOST !== parsed.host) {
     const NODE_ENV = config.util.getEnv('NODE_ENV')
     const NODE_CONFIG_DIR = config.util.getEnv('NODE_CONFIG_DIR')
 
@@ -34,6 +35,12 @@ async function checkActivityPubUrls () {
 // Return an error message, or null if everything is okay
 function checkConfig () {
 
+  // 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.')
+  }
+
+  // Email verification
   if (!Emailer.isEnabled()) {
     if (CONFIG.SIGNUP.ENABLED && CONFIG.SIGNUP.REQUIRES_EMAIL_VERIFICATION) {
       return 'Emailer is disabled but you require signup email verification.'
@@ -77,6 +84,8 @@ function checkConfig () {
     if (recentlyAddedStrategy && isNaN(recentlyAddedStrategy.minViews)) {
       return 'Min views in recently added strategy is not a number'
     }
+  } else {
+    return 'Videos redundancy should be an array (you must uncomment lines containing - too)'
   }
 
   // Check storage directory locations
diff --git a/server/initializers/checker-before-init.ts b/server/initializers/checker-before-init.ts
index 7905d9ffa..622ad7d6b 100644
--- a/server/initializers/checker-before-init.ts
+++ b/server/initializers/checker-before-init.ts
@@ -1,6 +1,5 @@
 import * as config from 'config'
 import { promisify0 } from '../helpers/core-utils'
-import { isArray } from '../helpers/custom-validators/misc'
 
 // ONLY USE CORE MODULES IN THIS FILE!
 
@@ -12,19 +11,24 @@ function checkMissedConfig () {
     'database.hostname', 'database.port', 'database.suffix', 'database.username', 'database.password', 'database.pool.max',
     'smtp.hostname', 'smtp.port', 'smtp.username', 'smtp.password', 'smtp.tls', 'smtp.from_address',
     'storage.avatars', 'storage.videos', 'storage.logs', 'storage.previews', 'storage.thumbnails', 'storage.torrents', 'storage.cache',
-    'storage.redundancy', 'storage.tmp',
+    'storage.redundancy', 'storage.tmp', 'storage.streaming_playlists',
     'log.level',
     'user.video_quota', 'user.video_quota_daily',
+    'csp.enabled', 'csp.report_only', 'csp.report_uri',
     'cache.previews.size', 'admin.email', 'contact_form.enabled',
     'signup.enabled', 'signup.limit', 'signup.requires_email_verification',
     'signup.filters.cidr.whitelist', 'signup.filters.cidr.blacklist',
     'redundancy.videos.strategies', 'redundancy.videos.check_interval',
     'transcoding.enabled', 'transcoding.threads', 'transcoding.allow_additional_extensions',
-    'import.videos.http.enabled', 'import.videos.torrent.enabled',
+    'import.videos.http.enabled', 'import.videos.torrent.enabled', 'auto_blacklist.videos.of_users.enabled',
     'trending.videos.interval_days',
     'instance.name', 'instance.short_description', 'instance.description', 'instance.terms', 'instance.default_client_route',
-    'instance.default_nsfw_policy', 'instance.robots', 'instance.securitytxt',
-    'services.twitter.username', 'services.twitter.whitelisted'
+    'instance.is_nsfw', 'instance.default_nsfw_policy', 'instance.robots', 'instance.securitytxt',
+    'services.twitter.username', 'services.twitter.whitelisted',
+    'followers.instance.enabled', 'followers.instance.manual_approval',
+    'tracker.enabled', 'tracker.private', 'tracker.reject_too_many_announces',
+    'history.videos.max_age', 'views.videos.remote.max_age',
+    'rates_limit.login.window', 'rates_limit.login.max', 'rates_limit.ask_send_email.window', 'rates_limit.ask_send_email.max'
   ]
   const requiredAlternatives = [
     [ // set
@@ -41,7 +45,8 @@ function checkMissedConfig () {
   }
 
   const redundancyVideos = config.get<any>('redundancy.videos.strategies')
-  if (isArray(redundancyVideos)) {
+
+  if (Array.isArray(redundancyVideos)) {
     for (const r of redundancyVideos) {
       if (!r.size) miss.push('redundancy.videos.strategies.size')
       if (!r.min_lifetime) miss.push('redundancy.videos.strategies.min_lifetime')
diff --git a/server/initializers/config.ts b/server/initializers/config.ts
new file mode 100644
index 000000000..4f77e144d
--- /dev/null
+++ b/server/initializers/config.ts
@@ -0,0 +1,277 @@
+import { IConfig } from 'config'
+import { dirname, join } from 'path'
+import { VideosRedundancy } from '../../shared/models'
+// Do not use barrels, remain constants as independent as possible
+import { buildPath, parseBytes, parseDurationToMs, root } from '../helpers/core-utils'
+import { NSFWPolicyType } from '../../shared/models/videos/nsfw-policy.type'
+import * as bytes from 'bytes'
+
+// Use a variable to reload the configuration if we need
+let config: IConfig = require('config')
+
+const configChangedHandlers: Function[] = []
+
+const CONFIG = {
+  CUSTOM_FILE: getLocalConfigFilePath(),
+  LISTEN: {
+    PORT: config.get<number>('listen.port'),
+    HOSTNAME: config.get<string>('listen.hostname')
+  },
+  DATABASE: {
+    DBNAME: 'peertube' + config.get<string>('database.suffix'),
+    HOSTNAME: config.get<string>('database.hostname'),
+    PORT: config.get<number>('database.port'),
+    USERNAME: config.get<string>('database.username'),
+    PASSWORD: config.get<string>('database.password'),
+    POOL: {
+      MAX: config.get<number>('database.pool.max')
+    }
+  },
+  REDIS: {
+    HOSTNAME: config.has('redis.hostname') ? config.get<string>('redis.hostname') : null,
+    PORT: config.has('redis.port') ? config.get<number>('redis.port') : null,
+    SOCKET: config.has('redis.socket') ? config.get<string>('redis.socket') : null,
+    AUTH: config.has('redis.auth') ? config.get<string>('redis.auth') : null,
+    DB: config.has('redis.db') ? config.get<number>('redis.db') : null
+  },
+  SMTP: {
+    HOSTNAME: config.get<string>('smtp.hostname'),
+    PORT: config.get<number>('smtp.port'),
+    USERNAME: config.get<string>('smtp.username'),
+    PASSWORD: config.get<string>('smtp.password'),
+    TLS: config.get<boolean>('smtp.tls'),
+    DISABLE_STARTTLS: config.get<boolean>('smtp.disable_starttls'),
+    CA_FILE: config.get<string>('smtp.ca_file'),
+    FROM_ADDRESS: config.get<string>('smtp.from_address')
+  },
+  STORAGE: {
+    TMP_DIR: buildPath(config.get<string>('storage.tmp')),
+    AVATARS_DIR: buildPath(config.get<string>('storage.avatars')),
+    LOG_DIR: buildPath(config.get<string>('storage.logs')),
+    VIDEOS_DIR: buildPath(config.get<string>('storage.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')),
+    PREVIEWS_DIR: buildPath(config.get<string>('storage.previews')),
+    CAPTIONS_DIR: buildPath(config.get<string>('storage.captions')),
+    TORRENTS_DIR: buildPath(config.get<string>('storage.torrents')),
+    CACHE_DIR: buildPath(config.get<string>('storage.cache'))
+  },
+  WEBSERVER: {
+    SCHEME: config.get<boolean>('webserver.https') === true ? 'https' : 'http',
+    WS: config.get<boolean>('webserver.https') === true ? 'wss' : 'ws',
+    HOSTNAME: config.get<string>('webserver.hostname'),
+    PORT: config.get<number>('webserver.port')
+  },
+  RATES_LIMIT: {
+    LOGIN: {
+      WINDOW_MS: parseDurationToMs(config.get<string>('rates_limit.login.window')),
+      MAX: config.get<number>('rates_limit.login.max')
+    },
+    ASK_SEND_EMAIL: {
+      WINDOW_MS: parseDurationToMs(config.get<string>('rates_limit.ask_send_email.window')),
+      MAX: config.get<number>('rates_limit.ask_send_email.max')
+    }
+  },
+  TRUST_PROXY: config.get<string[]>('trust_proxy'),
+  LOG: {
+    LEVEL: config.get<string>('log.level')
+  },
+  SEARCH: {
+    REMOTE_URI: {
+      USERS: config.get<boolean>('search.remote_uri.users'),
+      ANONYMOUS: config.get<boolean>('search.remote_uri.anonymous')
+    }
+  },
+  TRENDING: {
+    VIDEOS: {
+      INTERVAL_DAYS: config.get<number>('trending.videos.interval_days')
+    }
+  },
+  REDUNDANCY: {
+    VIDEOS: {
+      CHECK_INTERVAL: parseDurationToMs(config.get<string>('redundancy.videos.check_interval')),
+      STRATEGIES: buildVideosRedundancy(config.get<any[]>('redundancy.videos.strategies'))
+    }
+  },
+  CSP: {
+    ENABLED: config.get<boolean>('csp.enabled'),
+    REPORT_ONLY: config.get<boolean>('csp.report_only'),
+    REPORT_URI: config.get<boolean>('csp.report_uri')
+  },
+  TRACKER: {
+    ENABLED: config.get<boolean>('tracker.enabled'),
+    PRIVATE: config.get<boolean>('tracker.private'),
+    REJECT_TOO_MANY_ANNOUNCES: config.get<boolean>('tracker.reject_too_many_announces')
+  },
+  HISTORY: {
+    VIDEOS: {
+      MAX_AGE: parseDurationToMs(config.get('history.videos.max_age'))
+    }
+  },
+  VIEWS: {
+    VIDEOS: {
+      REMOTE: {
+        MAX_AGE: parseDurationToMs(config.get('views.videos.remote.max_age'))
+      }
+    }
+  },
+  ADMIN: {
+    get EMAIL () { return config.get<string>('admin.email') }
+  },
+  CONTACT_FORM: {
+    get ENABLED () { return config.get<boolean>('contact_form.enabled') }
+  },
+  SIGNUP: {
+    get ENABLED () { return config.get<boolean>('signup.enabled') },
+    get LIMIT () { return config.get<number>('signup.limit') },
+    get REQUIRES_EMAIL_VERIFICATION () { return config.get<boolean>('signup.requires_email_verification') },
+    FILTERS: {
+      CIDR: {
+        get WHITELIST () { return config.get<string[]>('signup.filters.cidr.whitelist') },
+        get BLACKLIST () { return config.get<string[]>('signup.filters.cidr.blacklist') }
+      }
+    }
+  },
+  USER: {
+    get VIDEO_QUOTA () { return parseBytes(config.get<number>('user.video_quota')) },
+    get VIDEO_QUOTA_DAILY () { return parseBytes(config.get<number>('user.video_quota_daily')) }
+  },
+  TRANSCODING: {
+    get ENABLED () { return config.get<boolean>('transcoding.enabled') },
+    get ALLOW_ADDITIONAL_EXTENSIONS () { return config.get<boolean>('transcoding.allow_additional_extensions') },
+    get THREADS () { return config.get<number>('transcoding.threads') },
+    RESOLUTIONS: {
+      get '240p' () { return config.get<boolean>('transcoding.resolutions.240p') },
+      get '360p' () { return config.get<boolean>('transcoding.resolutions.360p') },
+      get '480p' () { return config.get<boolean>('transcoding.resolutions.480p') },
+      get '720p' () { return config.get<boolean>('transcoding.resolutions.720p') },
+      get '1080p' () { return config.get<boolean>('transcoding.resolutions.1080p') }
+    },
+    HLS: {
+      get ENABLED () { return config.get<boolean>('transcoding.hls.enabled') }
+    }
+  },
+  IMPORT: {
+    VIDEOS: {
+      HTTP: {
+        get ENABLED () { return config.get<boolean>('import.videos.http.enabled') }
+      },
+      TORRENT: {
+        get ENABLED () { return config.get<boolean>('import.videos.torrent.enabled') }
+      }
+    }
+  },
+  AUTO_BLACKLIST: {
+    VIDEOS: {
+      OF_USERS: {
+        get ENABLED () { return config.get<boolean>('auto_blacklist.videos.of_users.enabled') }
+      }
+    }
+  },
+  CACHE: {
+    PREVIEWS: {
+      get SIZE () { return config.get<number>('cache.previews.size') }
+    },
+    VIDEO_CAPTIONS: {
+      get SIZE () { return config.get<number>('cache.captions.size') }
+    }
+  },
+  INSTANCE: {
+    get NAME () { return config.get<string>('instance.name') },
+    get SHORT_DESCRIPTION () { return config.get<string>('instance.short_description') },
+    get DESCRIPTION () { return config.get<string>('instance.description') },
+    get TERMS () { return config.get<string>('instance.terms') },
+    get IS_NSFW () { return config.get<boolean>('instance.is_nsfw') },
+    get DEFAULT_CLIENT_ROUTE () { return config.get<string>('instance.default_client_route') },
+    get DEFAULT_NSFW_POLICY () { return config.get<NSFWPolicyType>('instance.default_nsfw_policy') },
+    CUSTOMIZATIONS: {
+      get JAVASCRIPT () { return config.get<string>('instance.customizations.javascript') },
+      get CSS () { return config.get<string>('instance.customizations.css') }
+    },
+    get ROBOTS () { return config.get<string>('instance.robots') },
+    get SECURITYTXT () { return config.get<string>('instance.securitytxt') },
+    get SECURITYTXT_CONTACT () { return config.get<string>('admin.email') }
+  },
+  SERVICES: {
+    TWITTER: {
+      get USERNAME () { return config.get<string>('services.twitter.username') },
+      get WHITELISTED () { return config.get<boolean>('services.twitter.whitelisted') }
+    }
+  },
+  FOLLOWERS: {
+    INSTANCE: {
+      get ENABLED () { return config.get<boolean>('followers.instance.enabled') },
+      get MANUAL_APPROVAL () { return config.get<boolean>('followers.instance.manual_approval') }
+    }
+  }
+}
+
+function registerConfigChangedHandler (fun: Function) {
+  configChangedHandlers.push(fun)
+}
+
+// ---------------------------------------------------------------------------
+
+export {
+  CONFIG,
+  registerConfigChangedHandler
+}
+
+// ---------------------------------------------------------------------------
+
+function getLocalConfigFilePath () {
+  const configSources = config.util.getConfigSources()
+  if (configSources.length === 0) throw new Error('Invalid config source.')
+
+  let filename = 'local'
+  if (process.env.NODE_ENV) filename += `-${process.env.NODE_ENV}`
+  if (process.env.NODE_APP_INSTANCE) filename += `-${process.env.NODE_APP_INSTANCE}`
+
+  return join(dirname(configSources[ 0 ].name), filename + '.json')
+}
+
+function buildVideosRedundancy (objs: any[]): VideosRedundancy[] {
+  if (!objs) return []
+
+  if (!Array.isArray(objs)) return objs
+
+  return objs.map(obj => {
+    return Object.assign({}, obj, {
+      minLifetime: parseDurationToMs(obj.min_lifetime),
+      size: bytes.parse(obj.size),
+      minViews: obj.min_views
+    })
+  })
+}
+
+export function reloadConfig () {
+
+  function directory () {
+    if (process.env.NODE_CONFIG_DIR) {
+      return process.env.NODE_CONFIG_DIR
+    }
+
+    return join(root(), 'config')
+  }
+
+  function purge () {
+    for (const fileName in require.cache) {
+      if (-1 === fileName.indexOf(directory())) {
+        continue
+      }
+
+      delete require.cache[fileName]
+    }
+
+    delete require.cache[require.resolve('config')]
+  }
+
+  purge()
+
+  config = require('config')
+
+  for (const configChangedHandler of configChangedHandlers) {
+    configChangedHandler()
+  }
+}
diff --git a/server/initializers/constants.ts b/server/initializers/constants.ts
index 6f3ebb9aa..62778ae58 100644
--- a/server/initializers/constants.ts
+++ b/server/initializers/constants.ts
@@ -1,22 +1,20 @@
-import { IConfig } from 'config'
-import { dirname, join } from 'path'
-import { JobType, VideoRateType, VideoState, VideosRedundancy } from '../../shared/models'
+import { join } from 'path'
+import { JobType, VideoRateType, VideoState } from '../../shared/models'
 import { ActivityPubActorType } from '../../shared/models/activitypub'
 import { FollowState } from '../../shared/models/actors'
 import { VideoAbuseState, VideoImportState, VideoPrivacy, VideoTranscodingFPS } from '../../shared/models/videos'
 // Do not use barrels, remain constants as independent as possible
-import { buildPath, isTestInstance, parseDuration, parseBytes, root, sanitizeHost, sanitizeUrl } from '../helpers/core-utils'
+import { isTestInstance, sanitizeHost, sanitizeUrl } from '../helpers/core-utils'
 import { NSFWPolicyType } from '../../shared/models/videos/nsfw-policy.type'
 import { invert } from 'lodash'
 import { CronRepeatOptions, EveryRepeatOptions } from 'bull'
-import * as bytes from 'bytes'
-
-// Use a variable to reload the configuration if we need
-let config: IConfig = require('config')
+import { VideoPlaylistPrivacy } from '../../shared/models/videos/playlist/video-playlist-privacy.model'
+import { VideoPlaylistType } from '../../shared/models/videos/playlist/video-playlist-type.model'
+import { CONFIG, registerConfigChangedHandler } from './config'
 
 // ---------------------------------------------------------------------------
 
-const LAST_MIGRATION_VERSION = 325
+const LAST_MIGRATION_VERSION = 375
 
 // ---------------------------------------------------------------------------
 
@@ -30,6 +28,15 @@ const PAGINATION = {
   }
 }
 
+const WEBSERVER = {
+  URL: '',
+  HOST: '',
+  SCHEME: '',
+  WS: '',
+  HOSTNAME: '',
+  PORT: 0
+}
+
 // Sortable columns per schema
 const SORTABLE_COLUMNS = {
   USERS: [ 'id', 'username', 'createdAt' ],
@@ -40,6 +47,7 @@ const SORTABLE_COLUMNS = {
   VIDEO_CHANNELS: [ 'id', 'name', 'updatedAt', 'createdAt' ],
   VIDEO_IMPORTS: [ 'createdAt' ],
   VIDEO_COMMENT_THREADS: [ 'createdAt' ],
+  VIDEO_RATES: [ 'createdAt' ],
   BLACKLISTS: [ 'id', 'name', 'duration', 'views', 'likes', 'dislikes', 'uuid', 'createdAt' ],
   FOLLOWERS: [ 'createdAt' ],
   FOLLOWING: [ 'createdAt' ],
@@ -52,7 +60,9 @@ const SORTABLE_COLUMNS = {
   ACCOUNTS_BLOCKLIST: [ 'createdAt' ],
   SERVERS_BLOCKLIST: [ 'createdAt' ],
 
-  USER_NOTIFICATIONS: [ 'createdAt' ]
+  USER_NOTIFICATIONS: [ 'createdAt' ],
+
+  VIDEO_PLAYLISTS: [ 'displayName', 'createdAt', 'updatedAt' ]
 }
 
 const OAUTH_LIFETIME = {
@@ -96,36 +106,40 @@ const REMOTE_SCHEME = {
   WS: 'wss'
 }
 
-const JOB_ATTEMPTS: { [ id in JobType ]: number } = {
+// TODO: remove 'video-file'
+const JOB_ATTEMPTS: { [id in (JobType | 'video-file')]: number } = {
   'activitypub-http-broadcast': 5,
   'activitypub-http-unicast': 5,
   'activitypub-http-fetcher': 5,
   'activitypub-follow': 5,
   'video-file-import': 1,
+  'video-transcoding': 1,
   'video-file': 1,
   'video-import': 1,
   'email': 5,
   'videos-views': 1,
   'activitypub-refresher': 1
 }
-const JOB_CONCURRENCY: { [ id in JobType ]: number } = {
+const JOB_CONCURRENCY: { [id in (JobType | 'video-file')]: number } = {
   'activitypub-http-broadcast': 1,
   'activitypub-http-unicast': 5,
   'activitypub-http-fetcher': 1,
   'activitypub-follow': 3,
   'video-file-import': 1,
+  'video-transcoding': 1,
   'video-file': 1,
   'video-import': 1,
   'email': 5,
   'videos-views': 1,
   'activitypub-refresher': 1
 }
-const JOB_TTL: { [ id in JobType ]: number } = {
+const JOB_TTL: { [id in (JobType | 'video-file')]: number } = {
   'activitypub-http-broadcast': 60000 * 10, // 10 minutes
   'activitypub-http-unicast': 60000 * 10, // 10 minutes
   'activitypub-http-fetcher': 60000 * 10, // 10 minutes
   'activitypub-follow': 60000 * 10, // 10 minutes
   'video-file-import': 1000 * 3600, // 1 hour
+  'video-transcoding': 1000 * 3600 * 48, // 2 days, transcoding could be long
   'video-file': 1000 * 3600 * 48, // 2 days, transcoding could be long
   'video-import': 1000 * 3600 * 2, //  hours
   'email': 60000 * 10, // 10 minutes
@@ -144,163 +158,13 @@ const JOB_REQUEST_TIMEOUT = 3000 // 3 seconds
 const JOB_COMPLETED_LIFETIME = 60000 * 60 * 24 * 2 // 2 days
 const VIDEO_IMPORT_TIMEOUT = 1000 * 3600 // 1 hour
 
-// 1 hour
-let SCHEDULER_INTERVALS_MS = {
+const SCHEDULER_INTERVALS_MS = {
   actorFollowScores: 60000 * 60, // 1 hour
   removeOldJobs: 60000 * 60, // 1 hour
   updateVideos: 60000, // 1 minute
-  youtubeDLUpdate: 60000 * 60 * 24 // 1 day
-}
-
-// ---------------------------------------------------------------------------
-
-const CONFIG = {
-  CUSTOM_FILE: getLocalConfigFilePath(),
-  LISTEN: {
-    PORT: config.get<number>('listen.port'),
-    HOSTNAME: config.get<string>('listen.hostname')
-  },
-  DATABASE: {
-    DBNAME: 'peertube' + config.get<string>('database.suffix'),
-    HOSTNAME: config.get<string>('database.hostname'),
-    PORT: config.get<number>('database.port'),
-    USERNAME: config.get<string>('database.username'),
-    PASSWORD: config.get<string>('database.password'),
-    POOL: {
-      MAX: config.get<number>('database.pool.max')
-    }
-  },
-  REDIS: {
-    HOSTNAME: config.has('redis.hostname') ? config.get<string>('redis.hostname') : null,
-    PORT: config.has('redis.port') ? config.get<number>('redis.port') : null,
-    SOCKET: config.has('redis.socket') ? config.get<string>('redis.socket') : null,
-    AUTH: config.has('redis.auth') ? config.get<string>('redis.auth') : null,
-    DB: config.has('redis.db') ? config.get<number>('redis.db') : null
-  },
-  SMTP: {
-    HOSTNAME: config.get<string>('smtp.hostname'),
-    PORT: config.get<number>('smtp.port'),
-    USERNAME: config.get<string>('smtp.username'),
-    PASSWORD: config.get<string>('smtp.password'),
-    TLS: config.get<boolean>('smtp.tls'),
-    DISABLE_STARTTLS: config.get<boolean>('smtp.disable_starttls'),
-    CA_FILE: config.get<string>('smtp.ca_file'),
-    FROM_ADDRESS: config.get<string>('smtp.from_address')
-  },
-  STORAGE: {
-    TMP_DIR: buildPath(config.get<string>('storage.tmp')),
-    AVATARS_DIR: buildPath(config.get<string>('storage.avatars')),
-    LOG_DIR: buildPath(config.get<string>('storage.logs')),
-    VIDEOS_DIR: buildPath(config.get<string>('storage.videos')),
-    REDUNDANCY_DIR: buildPath(config.get<string>('storage.redundancy')),
-    THUMBNAILS_DIR: buildPath(config.get<string>('storage.thumbnails')),
-    PREVIEWS_DIR: buildPath(config.get<string>('storage.previews')),
-    CAPTIONS_DIR: buildPath(config.get<string>('storage.captions')),
-    TORRENTS_DIR: buildPath(config.get<string>('storage.torrents')),
-    CACHE_DIR: buildPath(config.get<string>('storage.cache'))
-  },
-  WEBSERVER: {
-    SCHEME: config.get<boolean>('webserver.https') === true ? 'https' : 'http',
-    WS: config.get<boolean>('webserver.https') === true ? 'wss' : 'ws',
-    HOSTNAME: config.get<string>('webserver.hostname'),
-    PORT: config.get<number>('webserver.port'),
-    URL: '',
-    HOST: ''
-  },
-  TRUST_PROXY: config.get<string[]>('trust_proxy'),
-  LOG: {
-    LEVEL: config.get<string>('log.level')
-  },
-  SEARCH: {
-    REMOTE_URI: {
-      USERS: config.get<boolean>('search.remote_uri.users'),
-      ANONYMOUS: config.get<boolean>('search.remote_uri.anonymous')
-    }
-  },
-  TRENDING: {
-    VIDEOS: {
-      INTERVAL_DAYS: config.get<number>('trending.videos.interval_days')
-    }
-  },
-  REDUNDANCY: {
-    VIDEOS: {
-      CHECK_INTERVAL: parseDuration(config.get<string>('redundancy.videos.check_interval')),
-      STRATEGIES: buildVideosRedundancy(config.get<any[]>('redundancy.videos.strategies'))
-    }
-  },
-  ADMIN: {
-    get EMAIL () { return config.get<string>('admin.email') }
-  },
-  CONTACT_FORM: {
-    get ENABLED () { return config.get<boolean>('contact_form.enabled') }
-  },
-  SIGNUP: {
-    get ENABLED () { return config.get<boolean>('signup.enabled') },
-    get LIMIT () { return config.get<number>('signup.limit') },
-    get REQUIRES_EMAIL_VERIFICATION () { return config.get<boolean>('signup.requires_email_verification') },
-    FILTERS: {
-      CIDR: {
-        get WHITELIST () { return config.get<string[]>('signup.filters.cidr.whitelist') },
-        get BLACKLIST () { return config.get<string[]>('signup.filters.cidr.blacklist') }
-      }
-    }
-  },
-  USER: {
-    get VIDEO_QUOTA () { return parseBytes(config.get<number>('user.video_quota')) },
-    get VIDEO_QUOTA_DAILY () { return parseBytes(config.get<number>('user.video_quota_daily')) }
-  },
-  TRANSCODING: {
-    get ENABLED () { return config.get<boolean>('transcoding.enabled') },
-    get ALLOW_ADDITIONAL_EXTENSIONS () { return config.get<boolean>('transcoding.allow_additional_extensions') },
-    get THREADS () { return config.get<number>('transcoding.threads') },
-    RESOLUTIONS: {
-      get '240p' () { return config.get<boolean>('transcoding.resolutions.240p') },
-      get '360p' () { return config.get<boolean>('transcoding.resolutions.360p') },
-      get '480p' () { return config.get<boolean>('transcoding.resolutions.480p') },
-      get '720p' () { return config.get<boolean>('transcoding.resolutions.720p') },
-      get '1080p' () { return config.get<boolean>('transcoding.resolutions.1080p') }
-    }
-  },
-  IMPORT: {
-    VIDEOS: {
-      HTTP: {
-        get ENABLED () { return config.get<boolean>('import.videos.http.enabled') }
-      },
-      TORRENT: {
-        get ENABLED () { return config.get<boolean>('import.videos.torrent.enabled') }
-      }
-    }
-  },
-  CACHE: {
-    PREVIEWS: {
-      get SIZE () { return config.get<number>('cache.previews.size') }
-    },
-    VIDEO_CAPTIONS: {
-      get SIZE () { return config.get<number>('cache.captions.size') }
-    }
-  },
-  INSTANCE: {
-    get NAME () { return config.get<string>('instance.name') },
-    get SHORT_DESCRIPTION () { return config.get<string>('instance.short_description') },
-    get DESCRIPTION () { return config.get<string>('instance.description') },
-    get TERMS () { return config.get<string>('instance.terms') },
-    get DEFAULT_CLIENT_ROUTE () { return config.get<string>('instance.default_client_route') },
-    get DEFAULT_NSFW_POLICY () { return config.get<NSFWPolicyType>('instance.default_nsfw_policy') },
-    CUSTOMIZATIONS: {
-      get JAVASCRIPT () { return config.get<string>('instance.customizations.javascript') },
-      get CSS () { return config.get<string>('instance.customizations.css') }
-    },
-    get ROBOTS () { return config.get<string>('instance.robots') },
-    get SECURITYTXT () { return config.get<string>('instance.securitytxt') },
-    get SECURITYTXT_CONTACT () { return config.get<string>('admin.email') }
-  },
-  SERVICES: {
-    get 'CSP-LOGGER' () { return config.get<string>('services.csp-logger') },
-    TWITTER: {
-      get USERNAME () { return config.get<string>('services.twitter.username') },
-      get WHITELISTED () { return config.get<boolean>('services.twitter.whitelisted') }
-    }
-  }
+  youtubeDLUpdate: 60000 * 60 * 24, // 1 day
+  removeOldViews: 60000 * 60 * 24, // 1 day
+  removeOldHistory: 60000 * 60 * 24 // 1 day
 }
 
 // ---------------------------------------------------------------------------
@@ -377,6 +241,17 @@ let CONSTRAINTS_FIELDS = {
     FILE_SIZE: { min: 10 },
     URL: { min: 3, max: 2000 } // Length
   },
+  VIDEO_PLAYLISTS: {
+    NAME: { min: 1, max: 120 }, // Length
+    DESCRIPTION: { min: 3, max: 1000 }, // Length
+    URL: { min: 3, max: 2000 }, // Length
+    IMAGE: {
+      EXTNAME: [ '.jpg', '.jpeg' ],
+      FILE_SIZE: {
+        max: 2 * 1024 * 1024 // 2MB
+      }
+    }
+  },
   ACTORS: {
     PUBLIC_KEY: { min: 10, max: 5000 }, // Length
     PRIVATE_KEY: { min: 10, max: 5000 }, // Length
@@ -406,12 +281,12 @@ let CONSTRAINTS_FIELDS = {
 
 const RATES_LIMIT = {
   LOGIN: {
-    WINDOW_MS: 5 * 60 * 1000, // 5 minutes
-    MAX: 15 // 15 attempts
+    WINDOW_MS: CONFIG.RATES_LIMIT.LOGIN.WINDOW_MS,
+    MAX: CONFIG.RATES_LIMIT.LOGIN.MAX
   },
   ASK_SEND_EMAIL: {
-    WINDOW_MS: 5 * 60 * 1000, // 5 minutes
-    MAX: 3 // 3 attempts
+    WINDOW_MS: CONFIG.RATES_LIMIT.ASK_SEND_EMAIL.WINDOW_MS,
+    MAX: CONFIG.RATES_LIMIT.ASK_SEND_EMAIL.MAX
   }
 }
 
@@ -467,30 +342,41 @@ const VIDEO_LICENCES = {
   7: 'Public Domain Dedication'
 }
 
-const VIDEO_LANGUAGES = buildLanguages()
+let VIDEO_LANGUAGES: { [id: string]: string } = {}
 
 const VIDEO_PRIVACIES = {
-  [VideoPrivacy.PUBLIC]: 'Public',
-  [VideoPrivacy.UNLISTED]: 'Unlisted',
-  [VideoPrivacy.PRIVATE]: 'Private'
+  [ VideoPrivacy.PUBLIC ]: 'Public',
+  [ VideoPrivacy.UNLISTED ]: 'Unlisted',
+  [ VideoPrivacy.PRIVATE ]: 'Private'
 }
 
 const VIDEO_STATES = {
-  [VideoState.PUBLISHED]: 'Published',
-  [VideoState.TO_TRANSCODE]: 'To transcode',
-  [VideoState.TO_IMPORT]: 'To import'
+  [ VideoState.PUBLISHED ]: 'Published',
+  [ VideoState.TO_TRANSCODE ]: 'To transcode',
+  [ VideoState.TO_IMPORT ]: 'To import'
 }
 
 const VIDEO_IMPORT_STATES = {
-  [VideoImportState.FAILED]: 'Failed',
-  [VideoImportState.PENDING]: 'Pending',
-  [VideoImportState.SUCCESS]: 'Success'
+  [ VideoImportState.FAILED ]: 'Failed',
+  [ VideoImportState.PENDING ]: 'Pending',
+  [ VideoImportState.SUCCESS ]: 'Success'
 }
 
 const VIDEO_ABUSE_STATES = {
-  [VideoAbuseState.PENDING]: 'Pending',
-  [VideoAbuseState.REJECTED]: 'Rejected',
-  [VideoAbuseState.ACCEPTED]: 'Accepted'
+  [ VideoAbuseState.PENDING ]: 'Pending',
+  [ VideoAbuseState.REJECTED ]: 'Rejected',
+  [ VideoAbuseState.ACCEPTED ]: 'Accepted'
+}
+
+const VIDEO_PLAYLIST_PRIVACIES = {
+  [ VideoPlaylistPrivacy.PUBLIC ]: 'Public',
+  [ VideoPlaylistPrivacy.UNLISTED ]: 'Unlisted',
+  [ VideoPlaylistPrivacy.PRIVATE ]: 'Private'
+}
+
+const VIDEO_PLAYLIST_TYPES = {
+  [ VideoPlaylistType.REGULAR ]: 'Regular',
+  [ VideoPlaylistType.WATCH_LATER ]: 'Watch later'
 }
 
 const MIMETYPES = {
@@ -548,8 +434,9 @@ const ACTIVITY_PUB = {
     MAGNET: [ 'application/x-bittorrent;x-scheme-handler/magnet' ]
   },
   MAX_RECURSION_COMMENTS: 100,
-  ACTOR_REFRESH_INTERVAL: 3600 * 24 * 1000, // 1 day
-  VIDEO_REFRESH_INTERVAL: 3600 * 24 * 1000 // 1 day
+  ACTOR_REFRESH_INTERVAL: 3600 * 24 * 1000 * 2, // 2 days
+  VIDEO_REFRESH_INTERVAL: 3600 * 24 * 1000 * 2, // 2 days
+  VIDEO_PLAYLIST_REFRESH_INTERVAL: 3600 * 24 * 1000 * 2 // 2 days
 }
 
 const ACTIVITY_PUB_ACTOR_TYPES: { [ id: string ]: ActivityPubActorType } = {
@@ -575,7 +462,7 @@ const USER_PASSWORD_RESET_LIFETIME = 60000 * 5 // 5 minutes
 
 const USER_EMAIL_VERIFY_LIFETIME = 60000 * 60 // 60 minutes
 
-const NSFW_POLICY_TYPES: { [ id: string]: NSFWPolicyType } = {
+const NSFW_POLICY_TYPES: { [ id: string ]: NSFWPolicyType } = {
   DO_NOT_LIST: 'do_not_list',
   BLUR: 'blur',
   DISPLAY: 'display'
@@ -590,6 +477,9 @@ const STATIC_PATHS = {
   TORRENTS: '/static/torrents/',
   WEBSEED: '/static/webseed/',
   REDUNDANCY: '/static/redundancy/',
+  STREAMING_PLAYLISTS: {
+    HLS: '/static/streaming-playlists/hls'
+  },
   AVATARS: '/static/avatars/',
   VIDEO_CAPTIONS: '/static/video-captions/'
 }
@@ -603,8 +493,8 @@ let STATIC_MAX_AGE = '2h'
 
 // Videos thumbnail size
 const THUMBNAILS_SIZE = {
-  width: 200,
-  height: 110
+  width: 223,
+  height: 122
 }
 const PREVIEWS_SIZE = {
   width: 560,
@@ -621,7 +511,7 @@ const EMBED_SIZE = {
 }
 
 // Sub folders of cache directory
-const CACHE = {
+const FILES_CACHE = {
   PREVIEWS: {
     DIRECTORY: join(CONFIG.STORAGE.CACHE_DIR, 'previews'),
     MAX_AGE: 1000 * 3600 * 3 // 3 hours
@@ -632,6 +522,15 @@ const CACHE = {
   }
 }
 
+const CACHE = {
+  USER_TOKENS: {
+    MAX_SIZE: 10000
+  }
+}
+
+const HLS_STREAMING_PLAYLIST_DIRECTORY = join(CONFIG.STORAGE.STREAMING_PLAYLISTS_DIR, 'hls')
+const HLS_REDUNDANCY_DIRECTORY = join(CONFIG.STORAGE.REDUNDANCY_DIR, 'hls')
+
 const MEMOIZE_TTL = {
   OVERVIEWS_SAMPLE: 1000 * 3600 * 4 // 4 hours
 }
@@ -650,7 +549,7 @@ const CUSTOM_HTML_TAG_COMMENTS = {
   TITLE: '<!-- title tag -->',
   DESCRIPTION: '<!-- description tag -->',
   CUSTOM_CSS: '<!-- custom css tag -->',
-  OPENGRAPH_AND_OEMBED: '<!-- open graph and oembed tags -->'
+  META_TAGS: '<!-- meta tags -->'
 }
 
 // ---------------------------------------------------------------------------
@@ -659,6 +558,8 @@ const FEEDS = {
   COUNT: 20
 }
 
+const MAX_LOGS_OUTPUT_CHARACTERS = 10 * 1000 * 1000
+
 // ---------------------------------------------------------------------------
 
 const TRACKER_RATE_LIMITS = {
@@ -667,6 +568,8 @@ const TRACKER_RATE_LIMITS = {
   ANNOUNCES_PER_IP: 30 // maximum announces for all our torrents in the interval
 }
 
+const P2P_MEDIA_LOADER_PEER_VERSION = 2
+
 // ---------------------------------------------------------------------------
 
 // Special constants for a test instance
@@ -683,38 +586,50 @@ if (isTestInstance() === true) {
   ACTIVITY_PUB.COLLECTION_ITEMS_PER_PAGE = 2
   ACTIVITY_PUB.ACTOR_REFRESH_INTERVAL = 10 * 1000 // 10 seconds
   ACTIVITY_PUB.VIDEO_REFRESH_INTERVAL = 10 * 1000 // 10 seconds
+  ACTIVITY_PUB.VIDEO_PLAYLIST_REFRESH_INTERVAL = 10 * 1000 // 10 seconds
 
   CONSTRAINTS_FIELDS.ACTORS.AVATAR.FILE_SIZE.max = 100 * 1024 // 100KB
 
   SCHEDULER_INTERVALS_MS.actorFollowScores = 1000
   SCHEDULER_INTERVALS_MS.removeOldJobs = 10000
+  SCHEDULER_INTERVALS_MS.removeOldHistory = 5000
+  SCHEDULER_INTERVALS_MS.removeOldViews = 5000
   SCHEDULER_INTERVALS_MS.updateVideos = 5000
-  REPEAT_JOBS['videos-views'] = { every: 5000 }
+  REPEAT_JOBS[ 'videos-views' ] = { every: 5000 }
 
   REDUNDANCY.VIDEOS.RANDOMIZED_FACTOR = 1
 
   VIDEO_VIEW_LIFETIME = 1000 // 1 second
   CONTACT_FORM_LIFETIME = 1000 // 1 second
 
-  JOB_ATTEMPTS['email'] = 1
+  JOB_ATTEMPTS[ 'email' ] = 1
 
-  CACHE.VIDEO_CAPTIONS.MAX_AGE = 3000
+  FILES_CACHE.VIDEO_CAPTIONS.MAX_AGE = 3000
   MEMOIZE_TTL.OVERVIEWS_SAMPLE = 1
   ROUTE_CACHE_LIFETIME.OVERVIEWS.VIDEOS = '0ms'
+
+  RATES_LIMIT.LOGIN.MAX = 20
 }
 
 updateWebserverUrls()
 
+registerConfigChangedHandler(() => {
+  updateWebserverUrls()
+  updateWebserverConfig()
+})
+
 // ---------------------------------------------------------------------------
 
 export {
+  WEBSERVER,
   API_VERSION,
+  HLS_REDUNDANCY_DIRECTORY,
+  P2P_MEDIA_LOADER_PEER_VERSION,
   AVATARS_SIZE,
   ACCEPT_HEADERS,
   BCRYPT_SALT_SIZE,
   TRACKER_RATE_LIMITS,
-  CACHE,
-  CONFIG,
+  FILES_CACHE,
   CONSTRAINTS_FIELDS,
   EMBED_SIZE,
   REDUNDANCY,
@@ -733,12 +648,15 @@ export {
   PRIVATE_RSA_KEY_SIZE,
   ROUTE_CACHE_LIFETIME,
   SORTABLE_COLUMNS,
+  HLS_STREAMING_PLAYLIST_DIRECTORY,
   FEEDS,
   JOB_TTL,
   NSFW_POLICY_TYPES,
   STATIC_MAX_AGE,
   STATIC_PATHS,
   VIDEO_IMPORT_TIMEOUT,
+  VIDEO_PLAYLIST_TYPES,
+  MAX_LOGS_OUTPUT_CHARACTERS,
   ACTIVITY_PUB,
   ACTIVITY_PUB_ACTOR_TYPES,
   THUMBNAILS_SIZE,
@@ -751,6 +669,7 @@ export {
   VIDEO_TRANSCODING_FPS,
   FFMPEG_NICE,
   VIDEO_ABUSE_STATES,
+  CACHE,
   JOB_REQUEST_TIMEOUT,
   USER_PASSWORD_RESET_LIFETIME,
   MEMOIZE_TTL,
@@ -767,22 +686,13 @@ export {
   VIDEO_IMPORT_STATES,
   VIDEO_VIEW_LIFETIME,
   CONTACT_FORM_LIFETIME,
+  VIDEO_PLAYLIST_PRIVACIES,
+  loadLanguages,
   buildLanguages
 }
 
 // ---------------------------------------------------------------------------
 
-function getLocalConfigFilePath () {
-  const configSources = config.util.getConfigSources()
-  if (configSources.length === 0) throw new Error('Invalid config source.')
-
-  let filename = 'local'
-  if (process.env.NODE_ENV) filename += `-${process.env.NODE_ENV}`
-  if (process.env.NODE_APP_INSTANCE) filename += `-${process.env.NODE_APP_INSTANCE}`
-
-  return join(dirname(configSources[ 0 ].name), filename + '.json')
-}
-
 function buildVideoMimetypeExt () {
   const data = {
     'video/webm': '.webm',
@@ -805,8 +715,12 @@ function buildVideoMimetypeExt () {
 }
 
 function updateWebserverUrls () {
-  CONFIG.WEBSERVER.URL = sanitizeUrl(CONFIG.WEBSERVER.SCHEME + '://' + CONFIG.WEBSERVER.HOSTNAME + ':' + CONFIG.WEBSERVER.PORT)
-  CONFIG.WEBSERVER.HOST = sanitizeHost(CONFIG.WEBSERVER.HOSTNAME + ':' + CONFIG.WEBSERVER.PORT, REMOTE_SCHEME.HTTP)
+  WEBSERVER.URL = sanitizeUrl(CONFIG.WEBSERVER.SCHEME + '://' + CONFIG.WEBSERVER.HOSTNAME + ':' + CONFIG.WEBSERVER.PORT)
+  WEBSERVER.HOST = sanitizeHost(CONFIG.WEBSERVER.HOSTNAME + ':' + CONFIG.WEBSERVER.PORT, REMOTE_SCHEME.HTTP)
+  WEBSERVER.SCHEME = CONFIG.WEBSERVER.SCHEME
+  WEBSERVER.WS = CONFIG.WEBSERVER.WS
+  WEBSERVER.HOSTNAME = CONFIG.WEBSERVER.HOSTNAME
+  WEBSERVER.PORT = CONFIG.WEBSERVER.PORT
 }
 
 function updateWebserverConfig () {
@@ -822,16 +736,8 @@ function buildVideosExtname () {
     : [ '.mp4', '.ogv', '.webm' ]
 }
 
-function buildVideosRedundancy (objs: any[]): VideosRedundancy[] {
-  if (!objs) return []
-
-  return objs.map(obj => {
-    return Object.assign({}, obj, {
-      minLifetime: parseDuration(obj.min_lifetime),
-      size: bytes.parse(obj.size),
-      minViews: obj.min_views
-    })
-  })
+function loadLanguages () {
+  Object.assign(VIDEO_LANGUAGES, buildLanguages())
 }
 
 function buildLanguages () {
@@ -866,42 +772,13 @@ function buildLanguages () {
   iso639
     .filter(l => {
       return (l.iso6391 !== null && l.type === 'living') ||
-        additionalLanguages[l.iso6393] === true
+        additionalLanguages[ l.iso6393 ] === true
     })
-    .forEach(l => languages[l.iso6391 || l.iso6393] = l.name)
+    .forEach(l => languages[ l.iso6391 || l.iso6393 ] = l.name)
 
   // Override Occitan label
-  languages['oc'] = 'Occitan'
+  languages[ 'oc' ] = 'Occitan'
+  languages[ 'el' ] = 'Greek'
 
   return languages
 }
-
-export function reloadConfig () {
-
-  function directory () {
-    if (process.env.NODE_CONFIG_DIR) {
-      return process.env.NODE_CONFIG_DIR
-    }
-
-    return join(root(), 'config')
-  }
-
-  function purge () {
-    for (const fileName in require.cache) {
-      if (-1 === fileName.indexOf(directory())) {
-        continue
-      }
-
-      delete require.cache[fileName]
-    }
-
-    delete require.cache[require.resolve('config')]
-  }
-
-  purge()
-
-  config = require('config')
-
-  updateWebserverConfig()
-  updateWebserverUrls()
-}
diff --git a/server/initializers/database.ts b/server/initializers/database.ts
index 84ad2079b..142063a99 100644
--- a/server/initializers/database.ts
+++ b/server/initializers/database.ts
@@ -21,7 +21,7 @@ import { VideoCommentModel } from '../models/video/video-comment'
 import { VideoFileModel } from '../models/video/video-file'
 import { VideoShareModel } from '../models/video/video-share'
 import { VideoTagModel } from '../models/video/video-tag'
-import { CONFIG } from './constants'
+import { CONFIG } from './config'
 import { ScheduleVideoUpdateModel } from '../models/video/schedule-video-update'
 import { VideoCaptionModel } from '../models/video/video-caption'
 import { VideoImportModel } from '../models/video/video-import'
@@ -33,6 +33,11 @@ import { AccountBlocklistModel } from '../models/account/account-blocklist'
 import { ServerBlocklistModel } from '../models/server/server-blocklist'
 import { UserNotificationModel } from '../models/account/user-notification'
 import { UserNotificationSettingModel } from '../models/account/user-notification-setting'
+import { VideoStreamingPlaylistModel } from '../models/video/video-streaming-playlist'
+import { VideoPlaylistModel } from '../models/video/video-playlist'
+import { VideoPlaylistElementModel } from '../models/video/video-playlist-element'
+import { ThumbnailModel } from '../models/video/thumbnail'
+import { QueryTypes, Transaction } from 'sequelize'
 
 require('pg').defaults.parseInt8 = true // Avoid BIGINT to be converted to string
 
@@ -54,8 +59,7 @@ const sequelizeTypescript = new SequelizeTypescript({
     max: poolMax
   },
   benchmark: isTestInstance(),
-  isolationLevel: SequelizeTypescript.Transaction.ISOLATION_LEVELS.SERIALIZABLE,
-  operatorsAliases: false,
+  isolationLevel: Transaction.ISOLATION_LEVELS.SERIALIZABLE,
   logging: (message: string, benchmark: number) => {
     if (process.env.NODE_DB_LOG === 'false') return
 
@@ -82,6 +86,7 @@ async function initDatabaseModels (silent: boolean) {
     AccountVideoRateModel,
     UserModel,
     VideoAbuseModel,
+    VideoModel,
     VideoChangeOwnershipModel,
     VideoChannelModel,
     VideoShareModel,
@@ -89,7 +94,6 @@ async function initDatabaseModels (silent: boolean) {
     VideoCaptionModel,
     VideoBlacklistModel,
     VideoTagModel,
-    VideoModel,
     VideoCommentModel,
     ScheduleVideoUpdateModel,
     VideoImportModel,
@@ -99,7 +103,11 @@ async function initDatabaseModels (silent: boolean) {
     AccountBlocklistModel,
     ServerBlocklistModel,
     UserNotificationModel,
-    UserNotificationSettingModel
+    UserNotificationSettingModel,
+    VideoStreamingPlaylistModel,
+    VideoPlaylistModel,
+    VideoPlaylistElementModel,
+    ThumbnailModel
   ])
 
   // Check extensions exist in the database
@@ -132,11 +140,16 @@ async function checkPostgresExtensions () {
 }
 
 async function checkPostgresExtension (extension: string) {
-  const query = `SELECT true AS enabled FROM pg_available_extensions WHERE name = '${extension}' AND installed_version IS NOT NULL;`
-  const [ res ] = await sequelizeTypescript.query(query, { raw: true })
+  const query = `SELECT 1 FROM pg_available_extensions WHERE name = '${extension}' AND installed_version IS NOT NULL;`
+  const options = {
+    type: QueryTypes.SELECT as QueryTypes.SELECT,
+    raw: true
+  }
+
+  const res = await sequelizeTypescript.query<object>(query, options)
 
-  if (!res || res.length === 0 || res[ 0 ][ 'enabled' ] !== true) {
-    // Try to create the extension ourself
+  if (!res || res.length === 0) {
+    // Try to create the extension ourselves
     try {
       await sequelizeTypescript.query(`CREATE EXTENSION ${extension};`, { raw: true })
 
diff --git a/server/initializers/index.ts b/server/initializers/index.ts
index fe9190a9c..0fc1a7363 100644
--- a/server/initializers/index.ts
+++ b/server/initializers/index.ts
@@ -1,5 +1,3 @@
-// Constants first, database in second!
-export * from './constants'
 export * from './database'
 export * from './installer'
 export * from './migrator'
diff --git a/server/initializers/installer.ts b/server/initializers/installer.ts
index b9a9da183..127449577 100644
--- a/server/initializers/installer.ts
+++ b/server/initializers/installer.ts
@@ -1,14 +1,15 @@
 import * as passwordGenerator from 'password-generator'
 import { UserRole } from '../../shared'
 import { logger } from '../helpers/logger'
-import { createApplicationActor, createUserAccountAndChannel } from '../lib/user'
+import { createApplicationActor, createUserAccountAndChannelAndPlaylist } from '../lib/user'
 import { UserModel } from '../models/account/user'
 import { ApplicationModel } from '../models/application/application'
 import { OAuthClientModel } from '../models/oauth/oauth-client'
 import { applicationExist, clientsExist, usersExist } from './checker-after-init'
-import { CACHE, CONFIG, LAST_MIGRATION_VERSION } from './constants'
+import { FILES_CACHE, HLS_STREAMING_PLAYLIST_DIRECTORY, LAST_MIGRATION_VERSION } from './constants'
 import { sequelizeTypescript } from './database'
-import { remove, ensureDir } from 'fs-extra'
+import { ensureDir, remove } from 'fs-extra'
+import { CONFIG } from './config'
 
 async function installApplication () {
   try {
@@ -24,7 +25,7 @@ async function installApplication () {
         }),
 
       // Directories
-      removeCacheDirectories()
+      removeCacheAndTmpDirectories()
         .then(() => createDirectoriesIfNotExist())
     ])
   } catch (err) {
@@ -41,9 +42,9 @@ export {
 
 // ---------------------------------------------------------------------------
 
-function removeCacheDirectories () {
-  const cacheDirectories = Object.keys(CACHE)
-    .map(k => CACHE[k].DIRECTORY)
+function removeCacheAndTmpDirectories () {
+  const cacheDirectories = Object.keys(FILES_CACHE)
+    .map(k => FILES_CACHE[k].DIRECTORY)
 
   const tasks: Promise<any>[] = []
 
@@ -53,13 +54,15 @@ function removeCacheDirectories () {
     tasks.push(remove(dir))
   }
 
+  tasks.push(remove(CONFIG.STORAGE.TMP_DIR))
+
   return Promise.all(tasks)
 }
 
 function createDirectoriesIfNotExist () {
   const storage = CONFIG.STORAGE
-  const cacheDirectories = Object.keys(CACHE)
-                                 .map(k => CACHE[k].DIRECTORY)
+  const cacheDirectories = Object.keys(FILES_CACHE)
+                                 .map(k => FILES_CACHE[k].DIRECTORY)
 
   const tasks: Promise<void>[] = []
   for (const key of Object.keys(storage)) {
@@ -73,6 +76,9 @@ function createDirectoriesIfNotExist () {
     tasks.push(ensureDir(dir))
   }
 
+  // Playlist directories
+  tasks.push(ensureDir(HLS_STREAMING_PLAYLIST_DIRECTORY))
+
   return Promise.all(tasks)
 }
 
@@ -138,7 +144,7 @@ async function createOAuthAdminIfNotExist () {
   }
   const user = new UserModel(userData)
 
-  await createUserAccountAndChannel(user, validatePassword)
+  await createUserAccountAndChannelAndPlaylist(user, validatePassword)
   logger.info('Username: ' + username)
   logger.info('User password: ' + password)
 }
diff --git a/server/initializers/migrations/0075-video-resolutions.ts b/server/initializers/migrations/0075-video-resolutions.ts
index 26a188e5e..e4f26cb77 100644
--- a/server/initializers/migrations/0075-video-resolutions.ts
+++ b/server/initializers/migrations/0075-video-resolutions.ts
@@ -1,6 +1,6 @@
 import * as Sequelize from 'sequelize'
 import { join } from 'path'
-import { CONFIG } from '../../initializers/constants'
+import { CONFIG } from '../../initializers/config'
 import { getVideoFileResolution } from '../../helpers/ffmpeg-utils'
 import { readdir, rename } from 'fs-extra'
 
diff --git a/server/initializers/migrations/0080-video-channels.ts b/server/initializers/migrations/0080-video-channels.ts
index f19721517..5512bdcf1 100644
--- a/server/initializers/migrations/0080-video-channels.ts
+++ b/server/initializers/migrations/0080-video-channels.ts
@@ -69,12 +69,12 @@ async function up (utils: {
   const options = {
     type: Sequelize.QueryTypes.SELECT
   }
-  const rawVideos = await utils.sequelize.query(query, options)
+  const rawVideos = await utils.sequelize.query(query, options) as any
 
   for (const rawVideo of rawVideos) {
     const videoChannel = await utils.db.VideoChannel.findOne({ where: { authorId: rawVideo.authorId } })
 
-    const video = await utils.db.Video.findById(rawVideo.id)
+    const video = await utils.db.Video.findByPk(rawVideo.id)
     video.channelId = videoChannel.id
     await video.save()
   }
diff --git a/server/initializers/migrations/0100-activitypub.ts b/server/initializers/migrations/0100-activitypub.ts
index a7ebd804c..2880a97d9 100644
--- a/server/initializers/migrations/0100-activitypub.ts
+++ b/server/initializers/migrations/0100-activitypub.ts
@@ -21,7 +21,7 @@ async function up (utils: {
     const options = {
       type: Sequelize.QueryTypes.SELECT
     }
-    const res = await utils.sequelize.query(query, options)
+    const res = await utils.sequelize.query(query, options) as any
 
     if (!res[0] || res[0].total !== 0) {
       throw new Error('You need to quit friends.')
@@ -68,8 +68,8 @@ async function up (utils: {
     const accountCreated = await createLocalAccountWithoutKeys(SERVER_ACTOR_NAME, null, applicationInstance.id, undefined)
 
     const { publicKey, privateKey } = await createPrivateAndPublicKeys()
-    accountCreated.set('publicKey', publicKey)
-    accountCreated.set('privateKey', privateKey)
+    accountCreated.Actor.publicKey = publicKey
+    accountCreated.Actor.privateKey = privateKey
 
     await accountCreated.save()
   }
@@ -86,8 +86,8 @@ async function up (utils: {
     const account = await createLocalAccountWithoutKeys(user.username, user.id, null, undefined)
 
     const { publicKey, privateKey } = await createPrivateAndPublicKeys()
-    account.set('publicKey', publicKey)
-    account.set('privateKey', privateKey)
+    account.Actor.publicKey = publicKey
+    account.Actor.privateKey = privateKey
     await account.save()
   }
 
diff --git a/server/initializers/migrations/0135-video-channel-actor.ts b/server/initializers/migrations/0135-video-channel-actor.ts
index 033f43b68..5ace0f4d2 100644
--- a/server/initializers/migrations/0135-video-channel-actor.ts
+++ b/server/initializers/migrations/0135-video-channel-actor.ts
@@ -239,7 +239,8 @@ async function up (utils: {
 
   {
     const query = 'SELECT * FROM "actor" WHERE "serverId" IS NULL AND "publicKey" IS NULL'
-    const [ res ] = await utils.sequelize.query(query)
+    const options = { type: Sequelize.QueryTypes.SELECT as Sequelize.QueryTypes.SELECT }
+    const [ res ] = await utils.sequelize.query(query, options)
 
     for (const actor of res) {
       const { privateKey, publicKey } = await createPrivateAndPublicKeys()
diff --git a/server/initializers/migrations/0140-actor-url.ts b/server/initializers/migrations/0140-actor-url.ts
index e64ee3487..020499391 100644
--- a/server/initializers/migrations/0140-actor-url.ts
+++ b/server/initializers/migrations/0140-actor-url.ts
@@ -1,13 +1,13 @@
 import * as Sequelize from 'sequelize'
-import { CONFIG } from '../constants'
+import { WEBSERVER } from '../constants'
 
 async function up (utils: {
   transaction: Sequelize.Transaction,
   queryInterface: Sequelize.QueryInterface,
   sequelize: Sequelize.Sequelize
 }): Promise<void> {
-  const toReplace = CONFIG.WEBSERVER.HOSTNAME + ':443'
-  const by = CONFIG.WEBSERVER.HOST
+  const toReplace = WEBSERVER.HOSTNAME + ':443'
+  const by = WEBSERVER.HOST
   const replacer = column => `replace("${column}", '${toReplace}', '${by}')`
 
   {
diff --git a/server/initializers/migrations/0170-actor-follow-score.ts b/server/initializers/migrations/0170-actor-follow-score.ts
index 2deabaf98..a12b35da9 100644
--- a/server/initializers/migrations/0170-actor-follow-score.ts
+++ b/server/initializers/migrations/0170-actor-follow-score.ts
@@ -1,5 +1,5 @@
 import * as Sequelize from 'sequelize'
-import { ACTOR_FOLLOW_SCORE } from '../index'
+import { ACTOR_FOLLOW_SCORE } from '../constants'
 
 async function up (utils: {
   transaction: Sequelize.Transaction,
diff --git a/server/initializers/migrations/0210-video-language.ts b/server/initializers/migrations/0210-video-language.ts
index b7ec90905..ca95c7527 100644
--- a/server/initializers/migrations/0210-video-language.ts
+++ b/server/initializers/migrations/0210-video-language.ts
@@ -1,5 +1,5 @@
 import * as Sequelize from 'sequelize'
-import { CONSTRAINTS_FIELDS } from '../index'
+import { CONSTRAINTS_FIELDS } from '../constants'
 
 async function up (utils: {
   transaction: Sequelize.Transaction,
diff --git a/server/initializers/migrations/0215-video-support-length.ts b/server/initializers/migrations/0215-video-support-length.ts
index 994eda60d..ba395050f 100644
--- a/server/initializers/migrations/0215-video-support-length.ts
+++ b/server/initializers/migrations/0215-video-support-length.ts
@@ -1,5 +1,4 @@
 import * as Sequelize from 'sequelize'
-import { CONSTRAINTS_FIELDS } from '../index'
 
 async function up (utils: {
   transaction: Sequelize.Transaction,
diff --git a/server/initializers/migrations/0235-delete-some-video-indexes.ts b/server/initializers/migrations/0235-delete-some-video-indexes.ts
index e362f240c..5964b0dc5 100644
--- a/server/initializers/migrations/0235-delete-some-video-indexes.ts
+++ b/server/initializers/migrations/0235-delete-some-video-indexes.ts
@@ -1,8 +1,4 @@
 import * as Sequelize from 'sequelize'
-import { createClient } from 'redis'
-import { CONFIG } from '../constants'
-import { JobQueue } from '../../lib/job-queue'
-import { initDatabaseModels } from '../database'
 
 async function up (utils: {
   transaction: Sequelize.Transaction
diff --git a/server/initializers/migrations/0240-drop-old-indexes.ts b/server/initializers/migrations/0240-drop-old-indexes.ts
index ba961e3f9..39868fa2d 100644
--- a/server/initializers/migrations/0240-drop-old-indexes.ts
+++ b/server/initializers/migrations/0240-drop-old-indexes.ts
@@ -1,8 +1,4 @@
 import * as Sequelize from 'sequelize'
-import { createClient } from 'redis'
-import { CONFIG } from '../constants'
-import { JobQueue } from '../../lib/job-queue'
-import { initDatabaseModels } from '../database'
 
 async function up (utils: {
   transaction: Sequelize.Transaction
diff --git a/server/initializers/migrations/0330-video-streaming-playlist.ts b/server/initializers/migrations/0330-video-streaming-playlist.ts
new file mode 100644
index 000000000..c85a762ab
--- /dev/null
+++ b/server/initializers/migrations/0330-video-streaming-playlist.ts
@@ -0,0 +1,51 @@
+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 "videoStreamingPlaylist"
+(
+  "id"                       SERIAL,
+  "type"                     INTEGER                  NOT NULL,
+  "playlistUrl"              VARCHAR(2000)            NOT NULL,
+  "p2pMediaLoaderInfohashes" VARCHAR(255)[]           NOT NULL,
+  "segmentsSha256Url"        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)
+  }
+
+  {
+    const data = {
+      type: Sequelize.INTEGER,
+      allowNull: true,
+      defaultValue: null
+    }
+
+    await utils.queryInterface.changeColumn('videoRedundancy', 'videoFileId', data)
+  }
+
+  {
+    const query = 'ALTER TABLE "videoRedundancy" ADD COLUMN "videoStreamingPlaylistId" INTEGER NULL ' +
+      'REFERENCES "videoStreamingPlaylist" ("id") ON DELETE CASCADE ON UPDATE CASCADE'
+
+    await utils.sequelize.query(query)
+  }
+}
+
+function down (options) {
+  throw new Error('Not implemented.')
+}
+
+export {
+  up,
+  down
+}
diff --git a/server/initializers/migrations/0335-video-downloading-enabled.ts b/server/initializers/migrations/0335-video-downloading-enabled.ts
new file mode 100644
index 000000000..e79466447
--- /dev/null
+++ b/server/initializers/migrations/0335-video-downloading-enabled.ts
@@ -0,0 +1,27 @@
+import * as Sequelize from 'sequelize'
+import { Migration } from '../../models/migrations'
+
+async function up (utils: {
+  transaction: Sequelize.Transaction,
+  queryInterface: Sequelize.QueryInterface,
+  sequelize: Sequelize.Sequelize
+}): Promise<void> {
+  const data = {
+    type: Sequelize.BOOLEAN,
+    allowNull: false,
+    defaultValue: true
+  } as Migration.Boolean
+  await utils.queryInterface.addColumn('video', 'downloadEnabled', data)
+
+  data.defaultValue = null
+  return utils.queryInterface.changeColumn('video', 'downloadEnabled', data)
+}
+
+function down (options) {
+  throw new Error('Not implemented.')
+}
+
+export {
+  up,
+  down
+}
diff --git a/server/initializers/migrations/0340-add-originally-published-at.ts b/server/initializers/migrations/0340-add-originally-published-at.ts
new file mode 100644
index 000000000..fe4f4a5f9
--- /dev/null
+++ b/server/initializers/migrations/0340-add-originally-published-at.ts
@@ -0,0 +1,25 @@
+import * as Sequelize from 'sequelize'
+
+async function up (utils: {
+  transaction: Sequelize.Transaction,
+  queryInterface: Sequelize.QueryInterface,
+  sequelize: Sequelize.Sequelize
+}): Promise<void> {
+
+  const data = {
+    type: Sequelize.DATE,
+    allowNull: true,
+    defaultValue: null
+  }
+  await utils.queryInterface.addColumn('video', 'originallyPublishedAt', data)
+
+}
+
+function down (options) {
+  throw new Error('Not implemented.')
+}
+
+export {
+  up,
+  down
+}
diff --git a/server/initializers/migrations/0345-video-playlists.ts b/server/initializers/migrations/0345-video-playlists.ts
new file mode 100644
index 000000000..de69f5b9e
--- /dev/null
+++ b/server/initializers/migrations/0345-video-playlists.ts
@@ -0,0 +1,88 @@
+import * as Sequelize from 'sequelize'
+import { VideoPlaylistPrivacy, VideoPlaylistType } from '../../../shared/models/videos'
+import * as uuidv4 from 'uuid/v4'
+import { WEBSERVER } from '../constants'
+
+async function up (utils: {
+  transaction: Sequelize.Transaction,
+  queryInterface: Sequelize.QueryInterface,
+  sequelize: Sequelize.Sequelize
+}): Promise<void> {
+  const transaction = utils.transaction
+
+  {
+    const query = `
+CREATE TABLE IF NOT EXISTS "videoPlaylist"
+(
+  "id"             SERIAL,
+  "name"           VARCHAR(255)             NOT NULL,
+  "description"    VARCHAR(255),
+  "privacy"        INTEGER                  NOT NULL,
+  "url"            VARCHAR(2000)            NOT NULL,
+  "uuid"           UUID                     NOT NULL,
+  "type"           INTEGER                  NOT NULL DEFAULT 1,
+  "ownerAccountId" INTEGER                  NOT NULL REFERENCES "account" ("id") ON DELETE CASCADE ON UPDATE CASCADE,
+  "videoChannelId" INTEGER REFERENCES "videoChannel" ("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 })
+  }
+
+  {
+    const query = `
+CREATE TABLE IF NOT EXISTS "videoPlaylistElement"
+(
+  "id"              SERIAL,
+  "url"             VARCHAR(2000)            NOT NULL,
+  "position"        INTEGER                  NOT NULL DEFAULT 1,
+  "startTimestamp"  INTEGER,
+  "stopTimestamp"   INTEGER,
+  "videoPlaylistId" INTEGER                  NOT NULL REFERENCES "videoPlaylist" ("id") ON DELETE CASCADE ON UPDATE CASCADE,
+  "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 })
+  }
+
+  {
+    const userQuery = 'SELECT "username" FROM "user";'
+
+    const options = { transaction, type: Sequelize.QueryTypes.SELECT as Sequelize.QueryTypes.SELECT }
+    const userResult = await utils.sequelize.query<{ username: string }>(userQuery, options)
+    const usernames = userResult.map(r => r.username)
+
+    for (const username of usernames) {
+      const uuid = uuidv4()
+
+      const baseUrl = WEBSERVER.URL + '/video-playlists/' + uuid
+      const query = `
+ INSERT INTO "videoPlaylist" ("url", "uuid", "name", "privacy", "type", "ownerAccountId", "createdAt", "updatedAt")
+ SELECT '${baseUrl}' AS "url",
+         '${uuid}' AS "uuid",
+         'Watch later' AS "name",
+         ${VideoPlaylistPrivacy.PRIVATE} AS "privacy",
+         ${VideoPlaylistType.WATCH_LATER} AS "type",
+         "account"."id" AS "ownerAccountId",
+         NOW() as "createdAt",
+         NOW() as "updatedAt"
+ FROM "user" INNER JOIN "account" ON "user"."id" = "account"."userId"
+ WHERE "user"."username" = '${username}'`
+
+      await utils.sequelize.query(query, { transaction })
+    }
+  }
+}
+
+function down (options) {
+  throw new Error('Not implemented.')
+}
+
+export {
+  up,
+  down
+}
diff --git a/server/initializers/migrations/0350-video-blacklist-type.ts b/server/initializers/migrations/0350-video-blacklist-type.ts
new file mode 100644
index 000000000..4849020ef
--- /dev/null
+++ b/server/initializers/migrations/0350-video-blacklist-type.ts
@@ -0,0 +1,64 @@
+import * as Sequelize from 'sequelize'
+import { VideoBlacklistType } from '../../../shared/models/videos'
+
+async function up (utils: {
+  transaction: Sequelize.Transaction,
+  queryInterface: Sequelize.QueryInterface,
+  sequelize: Sequelize.Sequelize,
+  db: any
+}): Promise<void> {
+  {
+    const data = {
+      type: Sequelize.INTEGER,
+      allowNull: true,
+      defaultValue: null
+    }
+
+    await utils.queryInterface.addColumn('videoBlacklist', 'type', data)
+  }
+
+  {
+    const query = 'UPDATE "videoBlacklist" SET "type" = ' + VideoBlacklistType.MANUAL
+    await utils.sequelize.query(query)
+  }
+
+  {
+    const data = {
+      type: Sequelize.INTEGER,
+      allowNull: false,
+      defaultValue: null
+    }
+    await utils.queryInterface.changeColumn('videoBlacklist', 'type', data)
+  }
+
+  {
+    const data = {
+      type: Sequelize.INTEGER,
+      defaultValue: null,
+      allowNull: true
+    }
+    await utils.queryInterface.addColumn('userNotificationSetting', 'videoAutoBlacklistAsModerator', data)
+  }
+
+  {
+    const query = 'UPDATE "userNotificationSetting" SET "videoAutoBlacklistAsModerator" = 3'
+    await utils.sequelize.query(query)
+  }
+
+  {
+    const data = {
+      type: Sequelize.INTEGER,
+      defaultValue: null,
+      allowNull: false
+    }
+    await utils.queryInterface.changeColumn('userNotificationSetting', 'videoAutoBlacklistAsModerator', data)
+  }
+}
+function down (options) {
+  throw new Error('Not implemented.')
+}
+
+export {
+  up,
+  down
+}
diff --git a/server/initializers/migrations/0355-p2p-peer-version.ts b/server/initializers/migrations/0355-p2p-peer-version.ts
new file mode 100644
index 000000000..18f23d9b7
--- /dev/null
+++ b/server/initializers/migrations/0355-p2p-peer-version.ts
@@ -0,0 +1,41 @@
+import * as Sequelize from 'sequelize'
+
+async function up (utils: {
+  transaction: Sequelize.Transaction,
+  queryInterface: Sequelize.QueryInterface,
+  sequelize: Sequelize.Sequelize,
+  db: any
+}): Promise<void> {
+
+  {
+    const data = {
+      type: Sequelize.INTEGER,
+      allowNull: true,
+      defaultValue: null
+    }
+    await utils.queryInterface.addColumn('videoStreamingPlaylist', 'p2pMediaLoaderPeerVersion', data)
+  }
+
+  {
+    const query = `UPDATE "videoStreamingPlaylist" SET "p2pMediaLoaderPeerVersion" = 0;`
+    await utils.sequelize.query(query)
+  }
+
+  {
+    const data = {
+      type: Sequelize.INTEGER,
+      allowNull: false,
+      defaultValue: null
+    }
+    await utils.queryInterface.changeColumn('videoStreamingPlaylist', 'p2pMediaLoaderPeerVersion', data)
+  }
+}
+
+function down (options) {
+  throw new Error('Not implemented.')
+}
+
+export {
+  up,
+  down
+}
diff --git a/server/initializers/migrations/0360-notification-instance-follower.ts b/server/initializers/migrations/0360-notification-instance-follower.ts
new file mode 100644
index 000000000..05caf8e1d
--- /dev/null
+++ b/server/initializers/migrations/0360-notification-instance-follower.ts
@@ -0,0 +1,40 @@
+import * as Sequelize from 'sequelize'
+
+async function up (utils: {
+  transaction: Sequelize.Transaction,
+  queryInterface: Sequelize.QueryInterface,
+  sequelize: Sequelize.Sequelize,
+  db: any
+}): Promise<void> {
+  {
+    const data = {
+      type: Sequelize.INTEGER,
+      defaultValue: null,
+      allowNull: true
+    }
+    await utils.queryInterface.addColumn('userNotificationSetting', 'newInstanceFollower', data)
+  }
+
+  {
+    const query = 'UPDATE "userNotificationSetting" SET "newInstanceFollower" = 1'
+    await utils.sequelize.query(query)
+  }
+
+  {
+    const data = {
+      type: Sequelize.INTEGER,
+      defaultValue: null,
+      allowNull: false
+    }
+    await utils.queryInterface.changeColumn('userNotificationSetting', 'newInstanceFollower', data)
+  }
+}
+
+function down (options) {
+  throw new Error('Not implemented.')
+}
+
+export {
+  up,
+  down
+}
diff --git a/server/initializers/migrations/0365-user-admin-flags.ts b/server/initializers/migrations/0365-user-admin-flags.ts
new file mode 100644
index 000000000..20553100a
--- /dev/null
+++ b/server/initializers/migrations/0365-user-admin-flags.ts
@@ -0,0 +1,40 @@
+import * as Sequelize from 'sequelize'
+
+async function up (utils: {
+  transaction: Sequelize.Transaction,
+  queryInterface: Sequelize.QueryInterface,
+  sequelize: Sequelize.Sequelize,
+  db: any
+}): Promise<void> {
+  {
+    const data = {
+      type: Sequelize.INTEGER,
+      defaultValue: null,
+      allowNull: true
+    }
+    await utils.queryInterface.addColumn('user', 'adminFlags', data)
+  }
+
+  {
+    const query = 'UPDATE "user" SET "adminFlags" = 0'
+    await utils.sequelize.query(query)
+  }
+
+  {
+    const data = {
+      type: Sequelize.INTEGER,
+      defaultValue: null,
+      allowNull: false
+    }
+    await utils.queryInterface.changeColumn('user', 'adminFlags', data)
+  }
+}
+
+function down (options) {
+  throw new Error('Not implemented.')
+}
+
+export {
+  up,
+  down
+}
diff --git a/server/initializers/migrations/0370-thumbnail.ts b/server/initializers/migrations/0370-thumbnail.ts
new file mode 100644
index 000000000..384ca1a15
--- /dev/null
+++ b/server/initializers/migrations/0370-thumbnail.ts
@@ -0,0 +1,50 @@
+import * as Sequelize from 'sequelize'
+
+async function up (utils: {
+  transaction: Sequelize.Transaction,
+  queryInterface: Sequelize.QueryInterface,
+  sequelize: Sequelize.Sequelize,
+  db: any
+}): Promise<void> {
+  {
+    const query = `
+CREATE TABLE IF NOT EXISTS "thumbnail"
+(
+  "id"              SERIAL,
+  "filename"        VARCHAR(255)             NOT NULL,
+  "height"          INTEGER DEFAULT NULL,
+  "width"           INTEGER DEFAULT NULL,
+  "type"            INTEGER                  NOT NULL,
+  "fileUrl"             VARCHAR(255),
+  "videoId"         INTEGER REFERENCES "video" ("id") ON DELETE CASCADE ON UPDATE CASCADE,
+  "videoPlaylistId" INTEGER REFERENCES "videoPlaylist" ("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)
+  }
+
+  {
+    // All video thumbnails
+    const query = 'INSERT INTO "thumbnail" ("filename", "type", "videoId", "height", "width", "createdAt", "updatedAt")' +
+      'SELECT uuid || \'.jpg\', 1, id, 110, 200, NOW(), NOW() FROM "video"'
+    await utils.sequelize.query(query)
+  }
+
+  {
+    // All video previews
+    const query = 'INSERT INTO "thumbnail" ("filename", "type", "videoId", "height", "width", "createdAt", "updatedAt")' +
+      'SELECT uuid || \'.jpg\', 2, id, 315, 560, NOW(), NOW() FROM "video"'
+    await utils.sequelize.query(query)
+  }
+}
+
+function down (options) {
+  throw new Error('Not implemented.')
+}
+
+export {
+  up,
+  down
+}
diff --git a/server/initializers/migrations/0375-account-description.ts b/server/initializers/migrations/0375-account-description.ts
new file mode 100644
index 000000000..1258563fd
--- /dev/null
+++ b/server/initializers/migrations/0375-account-description.ts
@@ -0,0 +1,25 @@
+import * as Sequelize from 'sequelize'
+
+async function up (utils: {
+  transaction: Sequelize.Transaction,
+  queryInterface: Sequelize.QueryInterface,
+  sequelize: Sequelize.Sequelize,
+  db: any
+}): Promise<void> {
+  const data = {
+    type: Sequelize.STRING(1000),
+    allowNull: true,
+    defaultValue: null
+  }
+
+  await utils.queryInterface.changeColumn('account', 'description', data)
+}
+
+function down (options) {
+  throw new Error('Not implemented.')
+}
+
+export {
+  up,
+  down
+}
diff --git a/server/initializers/migrator.ts b/server/initializers/migrator.ts
index adc2f9fb3..1cb0116b7 100644
--- a/server/initializers/migrator.ts
+++ b/server/initializers/migrator.ts
@@ -3,6 +3,7 @@ import { logger } from '../helpers/logger'
 import { LAST_MIGRATION_VERSION } from './constants'
 import { sequelizeTypescript } from './database'
 import { readdir } from 'fs-extra'
+import { QueryTypes } from 'sequelize'
 
 async function migrate () {
   const tables = await sequelizeTypescript.getQueryInterface().showAllTables()
@@ -13,7 +14,12 @@ async function migrate () {
 
   let actualVersion: number | null = null
 
-  const [ rows ] = await sequelizeTypescript.query('SELECT "migrationVersion" FROM "application"')
+  const query = 'SELECT "migrationVersion" FROM "application"'
+  const options = {
+    type: QueryTypes.SELECT as QueryTypes.SELECT
+  }
+
+  const rows = await sequelizeTypescript.query<{ migrationVersion: number }>(query, options)
   if (rows && rows[0] && rows[0].migrationVersion) {
     actualVersion = rows[0].migrationVersion
   }
diff --git a/server/lib/activitypub/actor.ts b/server/lib/activitypub/actor.ts
index 8215840da..25cd40905 100644
--- a/server/lib/activitypub/actor.ts
+++ b/server/lib/activitypub/actor.ts
@@ -12,7 +12,7 @@ import { logger } from '../../helpers/logger'
 import { createPrivateAndPublicKeys } from '../../helpers/peertube-crypto'
 import { doRequest, downloadImage } from '../../helpers/requests'
 import { getUrlFromWebfinger } from '../../helpers/webfinger'
-import { AVATARS_SIZE, CONFIG, MIMETYPES, sequelizeTypescript } from '../../initializers'
+import { AVATARS_SIZE, MIMETYPES, WEBSERVER } from '../../initializers/constants'
 import { AccountModel } from '../../models/account/account'
 import { ActorModel } from '../../models/activitypub/actor'
 import { AvatarModel } from '../../models/avatar/avatar'
@@ -21,6 +21,8 @@ import { VideoChannelModel } from '../../models/video/video-channel'
 import { JobQueue } from '../job-queue'
 import { getServerActor } from '../../helpers/utils'
 import { ActorFetchByUrlType, fetchActorByUrl } from '../../helpers/actor'
+import { CONFIG } from '../../initializers/config'
+import { sequelizeTypescript } from '../../initializers/database'
 
 // Set account keys, this could be long so process after the account creation and do not block the client
 function setAsyncActorKeys (actor: ActorModel) {
@@ -44,6 +46,7 @@ async function getOrCreateActorAndServerAndModel (
 ) {
   const actorUrl = getAPId(activityActor)
   let created = false
+  let accountPlaylistsUrl: string
 
   let actor = await fetchActorByUrl(actorUrl, fetchType)
   // Orphan actor (not associated to an account of channel) so recreate it
@@ -70,7 +73,8 @@ async function getOrCreateActorAndServerAndModel (
 
       try {
         // Don't recurse another time
-        ownerActor = await getOrCreateActorAndServerAndModel(accountAttributedTo.id, 'all', false)
+        const recurseIfNeeded = false
+        ownerActor = await getOrCreateActorAndServerAndModel(accountAttributedTo.id, 'all', recurseIfNeeded)
       } catch (err) {
         logger.error('Cannot get or create account attributed to video channel ' + actor.url)
         throw new Error(err)
@@ -79,6 +83,7 @@ async function getOrCreateActorAndServerAndModel (
 
     actor = await retryTransactionWrapper(saveActorAndServerAndModelIfNotExist, result, ownerActor)
     created = true
+    accountPlaylistsUrl = result.playlists
   }
 
   if (actor.Account) actor.Account.Actor = actor
@@ -92,6 +97,12 @@ async function getOrCreateActorAndServerAndModel (
     await JobQueue.Instance.createJob({ type: 'activitypub-http-fetcher', payload })
   }
 
+  // We created a new account: fetch the playlists
+  if (created === true && actor.Account && accountPlaylistsUrl) {
+    const payload = { uri: accountPlaylistsUrl, accountId: actor.Account.id, type: 'account-playlists' as 'account-playlists' }
+    await JobQueue.Instance.createJob({ type: 'activitypub-http-fetcher', payload })
+  }
+
   return actorRefreshed
 }
 
@@ -107,7 +118,7 @@ function buildActorInstance (type: ActivityPubActorType, url: string, preferredU
     followingCount: 0,
     inboxUrl: url + '/inbox',
     outboxUrl: url + '/outbox',
-    sharedInboxUrl: CONFIG.WEBSERVER.URL + '/inbox',
+    sharedInboxUrl: WEBSERVER.URL + '/inbox',
     followersUrl: url + '/followers',
     followingUrl: url + '/following'
   })
@@ -259,7 +270,7 @@ async function refreshActorIfNeeded (
       return { refreshed: true, actor }
     })
   } catch (err) {
-    logger.warn('Cannot refresh actor.', { err })
+    logger.warn('Cannot refresh actor %s.', actor.url, { err })
     return { actor, refreshed: false }
   }
 }
@@ -333,6 +344,8 @@ function saveActorAndServerAndModelIfNotExist (
       actorCreated.VideoChannel.Account = ownerActor.Account
     }
 
+    actorCreated.Server = server
+
     return actorCreated
   }
 }
@@ -342,6 +355,7 @@ type FetchRemoteActorResult = {
   name: string
   summary: string
   support?: string
+  playlists?: string
   avatarName?: string
   attributedTo: ActivityPubAttributedTo[]
 }
@@ -355,17 +369,18 @@ async function fetchRemoteActor (actorUrl: string): Promise<{ statusCode?: numbe
 
   logger.info('Fetching remote actor %s.', actorUrl)
 
-  const requestResult = await doRequest(options)
+  const requestResult = await doRequest<ActivityPubActor>(options)
   normalizeActor(requestResult.body)
 
-  const actorJSON: ActivityPubActor = requestResult.body
+  const actorJSON = requestResult.body
   if (isActorObjectValid(actorJSON) === false) {
     logger.debug('Remote actor JSON is not valid.', { actorJSON })
     return { result: undefined, statusCode: requestResult.response.statusCode }
   }
 
   if (checkUrlsSameHost(actorJSON.id, actorUrl) !== true) {
-    throw new Error('Actor url ' + actorUrl + ' has not the same host than its AP id ' + actorJSON.id)
+    logger.warn('Actor url %s has not the same host than its AP id %s', actorUrl, actorJSON.id)
+    return { result: undefined, statusCode: requestResult.response.statusCode }
   }
 
   const followersCount = await fetchActorTotalItems(actorJSON.followers)
@@ -398,6 +413,7 @@ async function fetchRemoteActor (actorUrl: string): Promise<{ statusCode?: numbe
       avatarName,
       summary: actorJSON.summary,
       support: actorJSON.support,
+      playlists: actorJSON.playlists,
       attributedTo: actorJSON.attributedTo
     }
   }
diff --git a/server/lib/activitypub/audience.ts b/server/lib/activitypub/audience.ts
index 10277eca7..771a01366 100644
--- a/server/lib/activitypub/audience.ts
+++ b/server/lib/activitypub/audience.ts
@@ -1,6 +1,6 @@
 import { Transaction } from 'sequelize'
 import { ActivityAudience } from '../../../shared/models/activitypub'
-import { ACTIVITY_PUB } from '../../initializers'
+import { ACTIVITY_PUB } from '../../initializers/constants'
 import { ActorModel } from '../../models/activitypub/actor'
 import { VideoModel } from '../../models/video/video'
 import { VideoCommentModel } from '../../models/video/video-comment'
diff --git a/server/lib/activitypub/cache-file.ts b/server/lib/activitypub/cache-file.ts
index f6f068b45..de5cc54ac 100644
--- a/server/lib/activitypub/cache-file.ts
+++ b/server/lib/activitypub/cache-file.ts
@@ -2,10 +2,27 @@ import { CacheFileObject } from '../../../shared/index'
 import { VideoModel } from '../../models/video/video'
 import { VideoRedundancyModel } from '../../models/redundancy/video-redundancy'
 import { Transaction } from 'sequelize'
+import { VideoStreamingPlaylistType } from '../../../shared/models/videos/video-streaming-playlist.type'
 
 function cacheFileActivityObjectToDBAttributes (cacheFileObject: CacheFileObject, video: VideoModel, byActor: { id?: number }) {
-  const url = cacheFileObject.url
 
+  if (cacheFileObject.url.mediaType === 'application/x-mpegURL') {
+    const url = cacheFileObject.url
+
+    const playlist = video.VideoStreamingPlaylists.find(t => t.type === VideoStreamingPlaylistType.HLS)
+    if (!playlist) throw new Error('Cannot find HLS playlist of video ' + video.url)
+
+    return {
+      expiresOn: new Date(cacheFileObject.expires),
+      url: cacheFileObject.id,
+      fileUrl: url.href,
+      strategy: null,
+      videoStreamingPlaylistId: playlist.id,
+      actorId: byActor.id
+    }
+  }
+
+  const url = cacheFileObject.url
   const videoFile = video.VideoFiles.find(f => {
     return f.resolution === url.height && f.fps === url.fps
   })
@@ -15,7 +32,7 @@ function cacheFileActivityObjectToDBAttributes (cacheFileObject: CacheFileObject
   return {
     expiresOn: new Date(cacheFileObject.expires),
     url: cacheFileObject.id,
-    fileUrl: cacheFileObject.url.href,
+    fileUrl: url.href,
     strategy: null,
     videoFileId: videoFile.id,
     actorId: byActor.id
@@ -51,8 +68,8 @@ function updateCacheFile (
 
   const attributes = cacheFileActivityObjectToDBAttributes(cacheFileObject, video, byActor)
 
-  redundancyModel.set('expires', attributes.expiresOn)
-  redundancyModel.set('fileUrl', attributes.fileUrl)
+  redundancyModel.expiresOn = attributes.expiresOn
+  redundancyModel.fileUrl = attributes.fileUrl
 
   return redundancyModel.save({ transaction: t })
 }
diff --git a/server/lib/activitypub/crawl.ts b/server/lib/activitypub/crawl.ts
index 1b9b14c2e..686eef04d 100644
--- a/server/lib/activitypub/crawl.ts
+++ b/server/lib/activitypub/crawl.ts
@@ -1,10 +1,14 @@
-import { ACTIVITY_PUB, JOB_REQUEST_TIMEOUT } from '../../initializers'
+import { ACTIVITY_PUB, JOB_REQUEST_TIMEOUT, WEBSERVER } from '../../initializers/constants'
 import { doRequest } from '../../helpers/requests'
 import { logger } from '../../helpers/logger'
 import * as Bluebird from 'bluebird'
 import { ActivityPubOrderedCollection } from '../../../shared/models/activitypub'
+import { parse } from 'url'
 
-async function crawlCollectionPage <T> (uri: string, handler: (items: T[]) => Promise<any> | Bluebird<any>) {
+type HandlerFunction<T> = (items: T[]) => (Promise<any> | Bluebird<any>)
+type CleanerFunction = (startedDate: Date) => (Promise<any> | Bluebird<any>)
+
+async function crawlCollectionPage <T> (uri: string, handler: HandlerFunction<T>, cleaner?: CleanerFunction) {
   logger.info('Crawling ActivityPub data on %s.', uri)
 
   const options = {
@@ -15,6 +19,8 @@ async function crawlCollectionPage <T> (uri: string, handler: (items: T[]) => Pr
     timeout: JOB_REQUEST_TIMEOUT
   }
 
+  const startDate = new Date()
+
   const response = await doRequest<ActivityPubOrderedCollection<T>>(options)
   const firstBody = response.body
 
@@ -22,6 +28,10 @@ async function crawlCollectionPage <T> (uri: string, handler: (items: T[]) => Pr
   let i = 0
   let nextLink = firstBody.first
   while (nextLink && i < limit) {
+    // Don't crawl ourselves
+    const remoteHost = parse(nextLink).host
+    if (remoteHost === WEBSERVER.HOST) continue
+
     options.uri = nextLink
 
     const { body } = await doRequest<ActivityPubOrderedCollection<T>>(options)
@@ -35,6 +45,8 @@ async function crawlCollectionPage <T> (uri: string, handler: (items: T[]) => Pr
       await handler(items)
     }
   }
+
+  if (cleaner) await cleaner(startDate)
 }
 
 export {
diff --git a/server/lib/activitypub/index.ts b/server/lib/activitypub/index.ts
index 6906bf9d3..d8c7d83b7 100644
--- a/server/lib/activitypub/index.ts
+++ b/server/lib/activitypub/index.ts
@@ -2,6 +2,7 @@ export * from './process'
 export * from './send'
 export * from './actor'
 export * from './share'
+export * from './playlist'
 export * from './videos'
 export * from './video-comments'
 export * from './video-rates'
diff --git a/server/lib/activitypub/playlist.ts b/server/lib/activitypub/playlist.ts
new file mode 100644
index 000000000..36a91faec
--- /dev/null
+++ b/server/lib/activitypub/playlist.ts
@@ -0,0 +1,213 @@
+import { PlaylistObject } from '../../../shared/models/activitypub/objects/playlist-object'
+import { crawlCollectionPage } from './crawl'
+import { ACTIVITY_PUB, CRAWL_REQUEST_CONCURRENCY } from '../../initializers/constants'
+import { AccountModel } from '../../models/account/account'
+import { isArray } from '../../helpers/custom-validators/misc'
+import { getOrCreateActorAndServerAndModel } from './actor'
+import { logger } from '../../helpers/logger'
+import { VideoPlaylistModel } from '../../models/video/video-playlist'
+import { doRequest } from '../../helpers/requests'
+import { checkUrlsSameHost } from '../../helpers/activitypub'
+import * as Bluebird from 'bluebird'
+import { PlaylistElementObject } from '../../../shared/models/activitypub/objects/playlist-element-object'
+import { getOrCreateVideoAndAccountAndChannel } from './videos'
+import { isPlaylistElementObjectValid, isPlaylistObjectValid } from '../../helpers/custom-validators/activitypub/playlist'
+import { VideoPlaylistElementModel } from '../../models/video/video-playlist-element'
+import { VideoModel } from '../../models/video/video'
+import { VideoPlaylistPrivacy } from '../../../shared/models/videos/playlist/video-playlist-privacy.model'
+import { sequelizeTypescript } from '../../initializers/database'
+import { createPlaylistMiniatureFromUrl } from '../thumbnail'
+import { FilteredModelAttributes } from '../../typings/sequelize'
+
+function playlistObjectToDBAttributes (playlistObject: PlaylistObject, byAccount: AccountModel, to: string[]) {
+  const privacy = to.indexOf(ACTIVITY_PUB.PUBLIC) !== -1 ? VideoPlaylistPrivacy.PUBLIC : VideoPlaylistPrivacy.UNLISTED
+
+  return {
+    name: playlistObject.name,
+    description: playlistObject.content,
+    privacy,
+    url: playlistObject.id,
+    uuid: playlistObject.uuid,
+    ownerAccountId: byAccount.id,
+    videoChannelId: null,
+    createdAt: new Date(playlistObject.published),
+    updatedAt: new Date(playlistObject.updated)
+  }
+}
+
+function playlistElementObjectToDBAttributes (elementObject: PlaylistElementObject, videoPlaylist: VideoPlaylistModel, video: VideoModel) {
+  return {
+    position: elementObject.position,
+    url: elementObject.id,
+    startTimestamp: elementObject.startTimestamp || null,
+    stopTimestamp: elementObject.stopTimestamp || null,
+    videoPlaylistId: videoPlaylist.id,
+    videoId: video.id
+  }
+}
+
+async function createAccountPlaylists (playlistUrls: string[], account: AccountModel) {
+  await Bluebird.map(playlistUrls, async playlistUrl => {
+    try {
+      const exists = await VideoPlaylistModel.doesPlaylistExist(playlistUrl)
+      if (exists === true) return
+
+      // Fetch url
+      const { body } = await doRequest<PlaylistObject>({
+        uri: playlistUrl,
+        json: true,
+        activityPub: true
+      })
+
+      if (!isPlaylistObjectValid(body)) {
+        throw new Error(`Invalid playlist object when fetch account playlists: ${JSON.stringify(body)}`)
+      }
+
+      if (!isArray(body.to)) {
+        throw new Error('Playlist does not have an audience.')
+      }
+
+      return createOrUpdateVideoPlaylist(body, account, body.to)
+    } catch (err) {
+      logger.warn('Cannot add playlist element %s.', playlistUrl, { err })
+    }
+  }, { concurrency: CRAWL_REQUEST_CONCURRENCY })
+}
+
+async function createOrUpdateVideoPlaylist (playlistObject: PlaylistObject, byAccount: AccountModel, to: string[]) {
+  const playlistAttributes = playlistObjectToDBAttributes(playlistObject, byAccount, to)
+
+  if (isArray(playlistObject.attributedTo) && playlistObject.attributedTo.length === 1) {
+    const actor = await getOrCreateActorAndServerAndModel(playlistObject.attributedTo[0])
+
+    if (actor.VideoChannel) {
+      playlistAttributes.videoChannelId = actor.VideoChannel.id
+    } else {
+      logger.warn('Attributed to of video playlist %s is not a video channel.', playlistObject.id, { playlistObject })
+    }
+  }
+
+  const [ playlist ] = await VideoPlaylistModel.upsert<VideoPlaylistModel>(playlistAttributes, { returning: true })
+
+  let accItems: string[] = []
+  await crawlCollectionPage<string>(playlistObject.id, items => {
+    accItems = accItems.concat(items)
+
+    return Promise.resolve()
+  })
+
+  const refreshedPlaylist = await VideoPlaylistModel.loadWithAccountAndChannel(playlist.id, null)
+
+  if (playlistObject.icon) {
+    try {
+      const thumbnailModel = await createPlaylistMiniatureFromUrl(playlistObject.icon.url, refreshedPlaylist)
+      await refreshedPlaylist.setAndSaveThumbnail(thumbnailModel, undefined)
+    } catch (err) {
+      logger.warn('Cannot generate thumbnail of %s.', playlistObject.id, { err })
+    }
+  }
+
+  return resetVideoPlaylistElements(accItems, refreshedPlaylist)
+}
+
+async function refreshVideoPlaylistIfNeeded (videoPlaylist: VideoPlaylistModel): Promise<VideoPlaylistModel> {
+  if (!videoPlaylist.isOutdated()) return videoPlaylist
+
+  try {
+    const { statusCode, playlistObject } = await fetchRemoteVideoPlaylist(videoPlaylist.url)
+    if (statusCode === 404) {
+      logger.info('Cannot refresh remote video playlist %s: it does not exist anymore. Deleting it.', videoPlaylist.url)
+
+      await videoPlaylist.destroy()
+      return undefined
+    }
+
+    if (playlistObject === undefined) {
+      logger.warn('Cannot refresh remote playlist %s: invalid body.', videoPlaylist.url)
+
+      await videoPlaylist.setAsRefreshed()
+      return videoPlaylist
+    }
+
+    const byAccount = videoPlaylist.OwnerAccount
+    await createOrUpdateVideoPlaylist(playlistObject, byAccount, playlistObject.to)
+
+    return videoPlaylist
+  } catch (err) {
+    logger.warn('Cannot refresh video playlist %s.', videoPlaylist.url, { err })
+
+    await videoPlaylist.setAsRefreshed()
+    return videoPlaylist
+  }
+}
+
+// ---------------------------------------------------------------------------
+
+export {
+  createAccountPlaylists,
+  playlistObjectToDBAttributes,
+  playlistElementObjectToDBAttributes,
+  createOrUpdateVideoPlaylist,
+  refreshVideoPlaylistIfNeeded
+}
+
+// ---------------------------------------------------------------------------
+
+async function resetVideoPlaylistElements (elementUrls: string[], playlist: VideoPlaylistModel) {
+  const elementsToCreate: FilteredModelAttributes<VideoPlaylistElementModel>[] = []
+
+  await Bluebird.map(elementUrls, async elementUrl => {
+    try {
+      // Fetch url
+      const { body } = await doRequest<PlaylistElementObject>({
+        uri: elementUrl,
+        json: true,
+        activityPub: true
+      })
+
+      if (!isPlaylistElementObjectValid(body)) throw new Error(`Invalid body in video get playlist element ${elementUrl}`)
+
+      if (checkUrlsSameHost(body.id, elementUrl) !== true) {
+        throw new Error(`Playlist element url ${elementUrl} host is different from the AP object id ${body.id}`)
+      }
+
+      const { video } = await getOrCreateVideoAndAccountAndChannel({ videoObject: { id: body.url }, fetchType: 'only-video' })
+
+      elementsToCreate.push(playlistElementObjectToDBAttributes(body, playlist, video))
+    } catch (err) {
+      logger.warn('Cannot add playlist element %s.', elementUrl, { err })
+    }
+  }, { concurrency: CRAWL_REQUEST_CONCURRENCY })
+
+  await sequelizeTypescript.transaction(async t => {
+    await VideoPlaylistElementModel.deleteAllOf(playlist.id, t)
+
+    for (const element of elementsToCreate) {
+      await VideoPlaylistElementModel.create(element, { transaction: t })
+    }
+  })
+
+  logger.info('Reset playlist %s with %s elements.', playlist.url, elementsToCreate.length)
+
+  return undefined
+}
+
+async function fetchRemoteVideoPlaylist (playlistUrl: string): Promise<{ statusCode: number, playlistObject: PlaylistObject }> {
+  const options = {
+    uri: playlistUrl,
+    method: 'GET',
+    json: true,
+    activityPub: true
+  }
+
+  logger.info('Fetching remote playlist %s.', playlistUrl)
+
+  const { response, body } = await doRequest(options)
+
+  if (isPlaylistObjectValid(body) === false || checkUrlsSameHost(body.id, playlistUrl) !== true) {
+    logger.debug('Remote video playlist JSON is not valid.', { body })
+    return { statusCode: response.statusCode, playlistObject: undefined }
+  }
+
+  return { statusCode: response.statusCode, playlistObject: body }
+}
diff --git a/server/lib/activitypub/process/process-create.ts b/server/lib/activitypub/process/process-create.ts
index 5f4d793a5..e882669ce 100644
--- a/server/lib/activitypub/process/process-create.ts
+++ b/server/lib/activitypub/process/process-create.ts
@@ -12,6 +12,8 @@ import { Notifier } from '../../notifier'
 import { processViewActivity } from './process-view'
 import { processDislikeActivity } from './process-dislike'
 import { processFlagActivity } from './process-flag'
+import { PlaylistObject } from '../../../../shared/models/activitypub/objects/playlist-object'
+import { createOrUpdateVideoPlaylist } from '../playlist'
 
 async function processCreateActivity (activity: ActivityCreate, byActor: ActorModel) {
   const activityObject = activity.object
@@ -38,7 +40,11 @@ async function processCreateActivity (activity: ActivityCreate, byActor: ActorMo
   }
 
   if (activityType === 'CacheFile') {
-    return retryTransactionWrapper(processCacheFile, activity, byActor)
+    return retryTransactionWrapper(processCreateCacheFile, activity, byActor)
+  }
+
+  if (activityType === 'Playlist') {
+    return retryTransactionWrapper(processCreatePlaylist, activity, byActor)
   }
 
   logger.warn('Unknown activity object type %s when creating activity.', activityType, { activity: activity.id })
@@ -63,7 +69,7 @@ async function processCreateVideo (activity: ActivityCreate) {
   return video
 }
 
-async function processCacheFile (activity: ActivityCreate, byActor: ActorModel) {
+async function processCreateCacheFile (activity: ActivityCreate, byActor: ActorModel) {
   const cacheFile = activity.object as CacheFileObject
 
   const { video } = await getOrCreateVideoAndAccountAndChannel({ videoObject: cacheFile.object })
@@ -98,3 +104,12 @@ async function processCreateVideoComment (activity: ActivityCreate, byActor: Act
 
   if (created === true) Notifier.Instance.notifyOnNewComment(comment)
 }
+
+async function processCreatePlaylist (activity: ActivityCreate, byActor: ActorModel) {
+  const playlistObject = activity.object as PlaylistObject
+  const byAccount = byActor.Account
+
+  if (!byAccount) throw new Error('Cannot create video playlist with the non account actor ' + byActor.url)
+
+  await createOrUpdateVideoPlaylist(playlistObject, byAccount, activity.to)
+}
diff --git a/server/lib/activitypub/process/process-delete.ts b/server/lib/activitypub/process/process-delete.ts
index 155d2ffcc..76f07fd8a 100644
--- a/server/lib/activitypub/process/process-delete.ts
+++ b/server/lib/activitypub/process/process-delete.ts
@@ -8,6 +8,7 @@ import { VideoModel } from '../../../models/video/video'
 import { VideoChannelModel } from '../../../models/video/video-channel'
 import { VideoCommentModel } from '../../../models/video/video-comment'
 import { forwardVideoRelatedActivity } from '../send/utils'
+import { VideoPlaylistModel } from '../../../models/video/video-playlist'
 
 async function processDeleteActivity (activity: ActivityDelete, byActor: ActorModel) {
   const objectUrl = typeof activity.object === 'string' ? activity.object : activity.object.id
@@ -45,6 +46,15 @@ async function processDeleteActivity (activity: ActivityDelete, byActor: ActorMo
     }
   }
 
+  {
+    const videoPlaylist = await VideoPlaylistModel.loadByUrlAndPopulateAccount(objectUrl)
+    if (videoPlaylist) {
+      if (videoPlaylist.isOwned()) throw new Error(`Remote instance cannot delete owned playlist ${videoPlaylist.url}.`)
+
+      return retryTransactionWrapper(processDeleteVideoPlaylist, byActor, videoPlaylist)
+    }
+  }
+
   return undefined
 }
 
@@ -70,6 +80,20 @@ async function processDeleteVideo (actor: ActorModel, videoToDelete: VideoModel)
   logger.info('Remote video with uuid %s removed.', videoToDelete.uuid)
 }
 
+async function processDeleteVideoPlaylist (actor: ActorModel, playlistToDelete: VideoPlaylistModel) {
+  logger.debug('Removing remote video playlist "%s".', playlistToDelete.uuid)
+
+  await sequelizeTypescript.transaction(async t => {
+    if (playlistToDelete.OwnerAccount.Actor.id !== actor.id) {
+      throw new Error('Account ' + actor.url + ' does not own video playlist ' + playlistToDelete.url)
+    }
+
+    await playlistToDelete.destroy({ transaction: t })
+  })
+
+  logger.info('Remote video playlist with uuid %s removed.', playlistToDelete.uuid)
+}
+
 async function processDeleteAccount (accountToRemove: AccountModel) {
   logger.debug('Removing remote account "%s".', accountToRemove.Actor.uuid)
 
diff --git a/server/lib/activitypub/process/process-follow.ts b/server/lib/activitypub/process/process-follow.ts
index 0cd537187..ed16ba172 100644
--- a/server/lib/activitypub/process/process-follow.ts
+++ b/server/lib/activitypub/process/process-follow.ts
@@ -4,9 +4,11 @@ import { logger } from '../../../helpers/logger'
 import { sequelizeTypescript } from '../../../initializers'
 import { ActorModel } from '../../../models/activitypub/actor'
 import { ActorFollowModel } from '../../../models/activitypub/actor-follow'
-import { sendAccept } from '../send'
+import { sendAccept, sendReject } from '../send'
 import { Notifier } from '../../notifier'
 import { getAPId } from '../../../helpers/activitypub'
+import { getServerActor } from '../../../helpers/utils'
+import { CONFIG } from '../../../initializers/config'
 
 async function processFollowActivity (activity: ActivityFollow, byActor: ActorModel) {
   const activityObject = getAPId(activity.object)
@@ -23,12 +25,23 @@ export {
 // ---------------------------------------------------------------------------
 
 async function processFollow (actor: ActorModel, targetActorURL: string) {
-  const { actorFollow, created } = await sequelizeTypescript.transaction(async t => {
+  const { actorFollow, created, isFollowingInstance } = await sequelizeTypescript.transaction(async t => {
     const targetActor = await ActorModel.loadByUrlAndPopulateAccountAndChannel(targetActorURL, t)
 
     if (!targetActor) throw new Error('Unknown actor')
     if (targetActor.isOwned() === false) throw new Error('This is not a local actor.')
 
+    const serverActor = await getServerActor()
+    const isFollowingInstance = targetActor.id === serverActor.id
+
+    if (isFollowingInstance && CONFIG.FOLLOWERS.INSTANCE.ENABLED === false) {
+      logger.info('Rejecting %s because instance followers are disabled.', targetActor.url)
+
+      await sendReject(actor, targetActor)
+
+      return { actorFollow: undefined }
+    }
+
     const [ actorFollow, created ] = await ActorFollowModel.findOrCreate({
       where: {
         actorId: actor.id,
@@ -37,15 +50,12 @@ async function processFollow (actor: ActorModel, targetActorURL: string) {
       defaults: {
         actorId: actor.id,
         targetActorId: targetActor.id,
-        state: 'accepted'
+        state: CONFIG.FOLLOWERS.INSTANCE.MANUAL_APPROVAL ? 'pending' : 'accepted'
       },
       transaction: t
     })
 
-    actorFollow.ActorFollower = actor
-    actorFollow.ActorFollowing = targetActor
-
-    if (actorFollow.state !== 'accepted') {
+    if (actorFollow.state !== 'accepted' && CONFIG.FOLLOWERS.INSTANCE.MANUAL_APPROVAL === false) {
       actorFollow.state = 'accepted'
       await actorFollow.save({ transaction: t })
     }
@@ -54,12 +64,18 @@ async function processFollow (actor: ActorModel, targetActorURL: string) {
     actorFollow.ActorFollowing = targetActor
 
     // Target sends to actor he accepted the follow request
-    await sendAccept(actorFollow)
+    if (actorFollow.state === 'accepted') await sendAccept(actorFollow)
 
-    return { actorFollow, created }
+    return { actorFollow, created, isFollowingInstance }
   })
 
-  if (created) Notifier.Instance.notifyOfNewFollow(actorFollow)
+  // Rejected
+  if (!actorFollow) return
+
+  if (created) {
+    if (isFollowingInstance) Notifier.Instance.notifyOfNewInstanceFollow(actorFollow)
+    else Notifier.Instance.notifyOfNewUserFollow(actorFollow)
+  }
 
   logger.info('Actor %s is followed by actor %s.', targetActorURL, actor.url)
 }
diff --git a/server/lib/activitypub/process/process-undo.ts b/server/lib/activitypub/process/process-undo.ts
index ed0177a67..2d48848fe 100644
--- a/server/lib/activitypub/process/process-undo.ts
+++ b/server/lib/activitypub/process/process-undo.ts
@@ -108,7 +108,10 @@ async function processUndoCacheFile (byActor: ActorModel, activity: ActivityUndo
 
   return sequelizeTypescript.transaction(async t => {
     const cacheFile = await VideoRedundancyModel.loadByUrl(cacheFileObject.id)
-    if (!cacheFile) throw new Error('Unknown video cache ' + cacheFileObject.id)
+    if (!cacheFile) {
+      logger.debug('Cannot undo unknown video cache %s.', cacheFileObject.id)
+      return
+    }
 
     if (cacheFile.actorId !== byActor.id) throw new Error('Cannot delete redundancy ' + cacheFile.url + ' of another actor.')
 
diff --git a/server/lib/activitypub/process/process-update.ts b/server/lib/activitypub/process/process-update.ts
index c6b42d846..54a9234bb 100644
--- a/server/lib/activitypub/process/process-update.ts
+++ b/server/lib/activitypub/process/process-update.ts
@@ -12,6 +12,8 @@ import { sanitizeAndCheckVideoTorrentObject } from '../../../helpers/custom-vali
 import { isCacheFileObjectValid } from '../../../helpers/custom-validators/activitypub/cache-file'
 import { createOrUpdateCacheFile } from '../cache-file'
 import { forwardVideoRelatedActivity } from '../send/utils'
+import { PlaylistObject } from '../../../../shared/models/activitypub/objects/playlist-object'
+import { createOrUpdateVideoPlaylist } from '../playlist'
 
 async function processUpdateActivity (activity: ActivityUpdate, byActor: ActorModel) {
   const objectType = activity.object.type
@@ -32,6 +34,10 @@ async function processUpdateActivity (activity: ActivityUpdate, byActor: ActorMo
     return retryTransactionWrapper(processUpdateCacheFile, byActorFull, activity)
   }
 
+  if (objectType === 'Playlist') {
+    return retryTransactionWrapper(processUpdatePlaylist, byActor, activity)
+  }
+
   return undefined
 }
 
@@ -114,9 +120,11 @@ async function processUpdateActor (actor: ActorModel, activity: ActivityUpdate)
 
       await actor.save({ transaction: t })
 
-      accountOrChannelInstance.set('name', actorAttributesToUpdate.name || actorAttributesToUpdate.preferredUsername)
-      accountOrChannelInstance.set('description', actorAttributesToUpdate.summary)
-      accountOrChannelInstance.set('support', actorAttributesToUpdate.support)
+      accountOrChannelInstance.name = actorAttributesToUpdate.name || actorAttributesToUpdate.preferredUsername
+      accountOrChannelInstance.description = actorAttributesToUpdate.summary
+
+      if (accountOrChannelInstance instanceof VideoChannelModel) accountOrChannelInstance.support = actorAttributesToUpdate.support
+
       await accountOrChannelInstance.save({ transaction: t })
     })
 
@@ -135,3 +143,12 @@ async function processUpdateActor (actor: ActorModel, activity: ActivityUpdate)
     throw err
   }
 }
+
+async function processUpdatePlaylist (byActor: ActorModel, activity: ActivityUpdate) {
+  const playlistObject = activity.object as PlaylistObject
+  const byAccount = byActor.Account
+
+  if (!byAccount) throw new Error('Cannot update video playlist with the non account actor ' + byActor.url)
+
+  await createOrUpdateVideoPlaylist(playlistObject, byAccount, activity.to)
+}
diff --git a/server/lib/activitypub/send/index.ts b/server/lib/activitypub/send/index.ts
index 79ba6c7fe..028936810 100644
--- a/server/lib/activitypub/send/index.ts
+++ b/server/lib/activitypub/send/index.ts
@@ -1,8 +1,10 @@
 export * from './send-accept'
+export * from './send-accept'
 export * from './send-announce'
 export * from './send-create'
 export * from './send-delete'
 export * from './send-follow'
 export * from './send-like'
+export * from './send-reject'
 export * from './send-undo'
 export * from './send-update'
diff --git a/server/lib/activitypub/send/send-accept.ts b/server/lib/activitypub/send/send-accept.ts
index b6abde13d..388a9ed23 100644
--- a/server/lib/activitypub/send/send-accept.ts
+++ b/server/lib/activitypub/send/send-accept.ts
@@ -17,7 +17,7 @@ async function sendAccept (actorFollow: ActorFollowModel) {
 
   logger.info('Creating job to accept follower %s.', follower.url)
 
-  const followUrl = getActorFollowActivityPubUrl(actorFollow)
+  const followUrl = getActorFollowActivityPubUrl(follower, me)
   const followData = buildFollowActivity(followUrl, follower, me)
 
   const url = getActorFollowAcceptActivityPubUrl(actorFollow)
diff --git a/server/lib/activitypub/send/send-create.ts b/server/lib/activitypub/send/send-create.ts
index e3fca0a17..28f18595b 100644
--- a/server/lib/activitypub/send/send-create.ts
+++ b/server/lib/activitypub/send/send-create.ts
@@ -3,13 +3,14 @@ import { ActivityAudience, ActivityCreate } from '../../../../shared/models/acti
 import { VideoPrivacy } from '../../../../shared/models/videos'
 import { ActorModel } from '../../../models/activitypub/actor'
 import { VideoModel } from '../../../models/video/video'
-import { VideoAbuseModel } from '../../../models/video/video-abuse'
 import { VideoCommentModel } from '../../../models/video/video-comment'
-import { getVideoAbuseActivityPubUrl, getVideoDislikeActivityPubUrl, getVideoViewActivityPubUrl } from '../url'
 import { broadcastToActors, broadcastToFollowers, sendVideoRelatedActivity, unicastTo } from './utils'
 import { audiencify, getActorsInvolvedInVideo, getAudience, getAudienceFromFollowersOf, getVideoCommentAudience } from '../audience'
 import { logger } from '../../../helpers/logger'
 import { VideoRedundancyModel } from '../../../models/redundancy/video-redundancy'
+import { VideoPlaylistModel } from '../../../models/video/video-playlist'
+import { VideoPlaylistPrivacy } from '../../../../shared/models/videos/playlist/video-playlist-privacy.model'
+import { getServerActor } from '../../../helpers/utils'
 
 async function sendCreateVideo (video: VideoModel, t: Transaction) {
   if (video.privacy === VideoPrivacy.PRIVATE) return undefined
@@ -25,34 +26,36 @@ async function sendCreateVideo (video: VideoModel, t: Transaction) {
   return broadcastToFollowers(createActivity, byActor, [ byActor ], t)
 }
 
-async function sendVideoAbuse (byActor: ActorModel, videoAbuse: VideoAbuseModel, video: VideoModel) {
-  if (!video.VideoChannel.Account.Actor.serverId) return // Local
-
-  const url = getVideoAbuseActivityPubUrl(videoAbuse)
-
-  logger.info('Creating job to send video abuse %s.', url)
-
-  // Custom audience, we only send the abuse to the origin instance
-  const audience = { to: [ video.VideoChannel.Account.Actor.url ], cc: [] }
-  const createActivity = buildCreateActivity(url, byActor, videoAbuse.toActivityPubObject(), audience)
-
-  return unicastTo(createActivity, byActor, video.VideoChannel.Account.Actor.sharedInboxUrl)
-}
-
-async function sendCreateCacheFile (byActor: ActorModel, fileRedundancy: VideoRedundancyModel) {
+async function sendCreateCacheFile (byActor: ActorModel, video: VideoModel, fileRedundancy: VideoRedundancyModel) {
   logger.info('Creating job to send file cache of %s.', fileRedundancy.url)
 
-  const video = await VideoModel.loadAndPopulateAccountAndServerAndTags(fileRedundancy.VideoFile.Video.id)
-  const redundancyObject = fileRedundancy.toActivityPubObject()
-
   return sendVideoRelatedCreateActivity({
     byActor,
     video,
     url: fileRedundancy.url,
-    object: redundancyObject
+    object: fileRedundancy.toActivityPubObject()
   })
 }
 
+async function sendCreateVideoPlaylist (playlist: VideoPlaylistModel, t: Transaction) {
+  if (playlist.privacy === VideoPlaylistPrivacy.PRIVATE) return undefined
+
+  logger.info('Creating job to send create video playlist of %s.', playlist.url)
+
+  const byActor = playlist.OwnerAccount.Actor
+  const audience = getAudience(byActor, playlist.privacy === VideoPlaylistPrivacy.PUBLIC)
+
+  const object = await playlist.toActivityPubObject(null, t)
+  const createActivity = buildCreateActivity(playlist.url, byActor, object, audience)
+
+  const serverActor = await getServerActor()
+  const toFollowersOf = [ byActor, serverActor ]
+
+  if (playlist.VideoChannel) toFollowersOf.push(playlist.VideoChannel.Actor)
+
+  return broadcastToFollowers(createActivity, byActor, toFollowersOf, t)
+}
+
 async function sendCreateVideoComment (comment: VideoCommentModel, t: Transaction) {
   logger.info('Creating job to send comment %s.', comment.url)
 
@@ -91,37 +94,6 @@ async function sendCreateVideoComment (comment: VideoCommentModel, t: Transactio
   return unicastTo(createActivity, byActor, comment.Video.VideoChannel.Account.Actor.sharedInboxUrl)
 }
 
-async function sendCreateView (byActor: ActorModel, video: VideoModel, t: Transaction) {
-  logger.info('Creating job to send view of %s.', video.url)
-
-  const url = getVideoViewActivityPubUrl(byActor, video)
-  const viewActivity = buildViewActivity(url, byActor, video)
-
-  return sendVideoRelatedCreateActivity({
-    // Use the server actor to send the view
-    byActor,
-    video,
-    url,
-    object: viewActivity,
-    transaction: t
-  })
-}
-
-async function sendCreateDislike (byActor: ActorModel, video: VideoModel, t: Transaction) {
-  logger.info('Creating job to dislike %s.', video.url)
-
-  const url = getVideoDislikeActivityPubUrl(byActor, video)
-  const dislikeActivity = buildDislikeActivity(url, byActor, video)
-
-  return sendVideoRelatedCreateActivity({
-    byActor,
-    video,
-    url,
-    object: dislikeActivity,
-    transaction: t
-  })
-}
-
 function buildCreateActivity (url: string, byActor: ActorModel, object: any, audience?: ActivityAudience): ActivityCreate {
   if (!audience) audience = getAudience(byActor)
 
@@ -136,34 +108,13 @@ function buildCreateActivity (url: string, byActor: ActorModel, object: any, aud
   )
 }
 
-function buildDislikeActivity (url: string, byActor: ActorModel, video: VideoModel) {
-  return {
-    id: url,
-    type: 'Dislike',
-    actor: byActor.url,
-    object: video.url
-  }
-}
-
-function buildViewActivity (url: string, byActor: ActorModel, video: VideoModel) {
-  return {
-    id: url,
-    type: 'View',
-    actor: byActor.url,
-    object: video.url
-  }
-}
-
 // ---------------------------------------------------------------------------
 
 export {
   sendCreateVideo,
-  sendVideoAbuse,
   buildCreateActivity,
-  sendCreateView,
-  sendCreateDislike,
-  buildDislikeActivity,
   sendCreateVideoComment,
+  sendCreateVideoPlaylist,
   sendCreateCacheFile
 }
 
diff --git a/server/lib/activitypub/send/send-delete.ts b/server/lib/activitypub/send/send-delete.ts
index 18969433a..7bf5ca520 100644
--- a/server/lib/activitypub/send/send-delete.ts
+++ b/server/lib/activitypub/send/send-delete.ts
@@ -8,6 +8,8 @@ import { getDeleteActivityPubUrl } from '../url'
 import { broadcastToActors, broadcastToFollowers, sendVideoRelatedActivity, unicastTo } from './utils'
 import { audiencify, getActorsInvolvedInVideo, getVideoCommentAudience } from '../audience'
 import { logger } from '../../../helpers/logger'
+import { VideoPlaylistModel } from '../../../models/video/video-playlist'
+import { getServerActor } from '../../../helpers/utils'
 
 async function sendDeleteVideo (video: VideoModel, transaction: Transaction) {
   logger.info('Creating job to broadcast delete of video %s.', video.url)
@@ -29,7 +31,12 @@ async function sendDeleteActor (byActor: ActorModel, t: Transaction) {
   const url = getDeleteActivityPubUrl(byActor.url)
   const activity = buildDeleteActivity(url, byActor.url, byActor)
 
-  const actorsInvolved = await VideoShareModel.loadActorsByVideoOwner(byActor.id, t)
+  const actorsInvolved = await VideoShareModel.loadActorsWhoSharedVideosOf(byActor.id, t)
+
+  // In case the actor did not have any videos
+  const serverActor = await getServerActor()
+  actorsInvolved.push(serverActor)
+
   actorsInvolved.push(byActor)
 
   return broadcastToFollowers(activity, byActor, actorsInvolved, t)
@@ -64,12 +71,29 @@ async function sendDeleteVideoComment (videoComment: VideoCommentModel, t: Trans
   return unicastTo(activity, byActor, videoComment.Video.VideoChannel.Account.Actor.sharedInboxUrl)
 }
 
+async function sendDeleteVideoPlaylist (videoPlaylist: VideoPlaylistModel, t: Transaction) {
+  logger.info('Creating job to send delete of playlist %s.', videoPlaylist.url)
+
+  const byActor = videoPlaylist.OwnerAccount.Actor
+
+  const url = getDeleteActivityPubUrl(videoPlaylist.url)
+  const activity = buildDeleteActivity(url, videoPlaylist.url, byActor)
+
+  const serverActor = await getServerActor()
+  const toFollowersOf = [ byActor, serverActor ]
+
+  if (videoPlaylist.VideoChannel) toFollowersOf.push(videoPlaylist.VideoChannel.Actor)
+
+  return broadcastToFollowers(activity, byActor, toFollowersOf, t)
+}
+
 // ---------------------------------------------------------------------------
 
 export {
   sendDeleteVideo,
   sendDeleteActor,
-  sendDeleteVideoComment
+  sendDeleteVideoComment,
+  sendDeleteVideoPlaylist
 }
 
 // ---------------------------------------------------------------------------
diff --git a/server/lib/activitypub/send/send-dislike.ts b/server/lib/activitypub/send/send-dislike.ts
new file mode 100644
index 000000000..a88436f2c
--- /dev/null
+++ b/server/lib/activitypub/send/send-dislike.ts
@@ -0,0 +1,41 @@
+import { Transaction } from 'sequelize'
+import { ActorModel } from '../../../models/activitypub/actor'
+import { VideoModel } from '../../../models/video/video'
+import { getVideoDislikeActivityPubUrl } from '../url'
+import { logger } from '../../../helpers/logger'
+import { ActivityAudience, ActivityDislike } from '../../../../shared/models/activitypub'
+import { sendVideoRelatedActivity } from './utils'
+import { audiencify, getAudience } from '../audience'
+
+async function sendDislike (byActor: ActorModel, video: VideoModel, t: Transaction) {
+  logger.info('Creating job to dislike %s.', video.url)
+
+  const activityBuilder = (audience: ActivityAudience) => {
+    const url = getVideoDislikeActivityPubUrl(byActor, video)
+
+    return buildDislikeActivity(url, byActor, video, audience)
+  }
+
+  return sendVideoRelatedActivity(activityBuilder, { byActor, video, transaction: t })
+}
+
+function buildDislikeActivity (url: string, byActor: ActorModel, video: VideoModel, audience?: ActivityAudience): ActivityDislike {
+  if (!audience) audience = getAudience(byActor)
+
+  return audiencify(
+    {
+      id: url,
+      type: 'Dislike' as 'Dislike',
+      actor: byActor.url,
+      object: video.url
+    },
+    audience
+  )
+}
+
+// ---------------------------------------------------------------------------
+
+export {
+  sendDislike,
+  buildDislikeActivity
+}
diff --git a/server/lib/activitypub/send/send-flag.ts b/server/lib/activitypub/send/send-flag.ts
new file mode 100644
index 000000000..96a7311b9
--- /dev/null
+++ b/server/lib/activitypub/send/send-flag.ts
@@ -0,0 +1,39 @@
+import { ActorModel } from '../../../models/activitypub/actor'
+import { VideoModel } from '../../../models/video/video'
+import { VideoAbuseModel } from '../../../models/video/video-abuse'
+import { getVideoAbuseActivityPubUrl } from '../url'
+import { unicastTo } from './utils'
+import { logger } from '../../../helpers/logger'
+import { ActivityAudience, ActivityFlag } from '../../../../shared/models/activitypub'
+import { audiencify, getAudience } from '../audience'
+
+async function sendVideoAbuse (byActor: ActorModel, videoAbuse: VideoAbuseModel, video: VideoModel) {
+  if (!video.VideoChannel.Account.Actor.serverId) return // Local user
+
+  const url = getVideoAbuseActivityPubUrl(videoAbuse)
+
+  logger.info('Creating job to send video abuse %s.', url)
+
+  // Custom audience, we only send the abuse to the origin instance
+  const audience = { to: [ video.VideoChannel.Account.Actor.url ], cc: [] }
+  const flagActivity = buildFlagActivity(url, byActor, videoAbuse, audience)
+
+  return unicastTo(flagActivity, byActor, video.VideoChannel.Account.Actor.sharedInboxUrl)
+}
+
+function buildFlagActivity (url: string, byActor: ActorModel, videoAbuse: VideoAbuseModel, audience: ActivityAudience): ActivityFlag {
+  if (!audience) audience = getAudience(byActor)
+
+  const activity = Object.assign(
+    { id: url, actor: byActor.url },
+    videoAbuse.toActivityPubObject()
+  )
+
+  return audiencify(activity, audience)
+}
+
+// ---------------------------------------------------------------------------
+
+export {
+  sendVideoAbuse
+}
diff --git a/server/lib/activitypub/send/send-follow.ts b/server/lib/activitypub/send/send-follow.ts
index 170b46b48..2c3d02014 100644
--- a/server/lib/activitypub/send/send-follow.ts
+++ b/server/lib/activitypub/send/send-follow.ts
@@ -14,7 +14,7 @@ function sendFollow (actorFollow: ActorFollowModel) {
 
   logger.info('Creating job to send follow request to %s.', following.url)
 
-  const url = getActorFollowActivityPubUrl(actorFollow)
+  const url = getActorFollowActivityPubUrl(me, following)
   const data = buildFollowActivity(url, me, following)
 
   return unicastTo(data, me, following.inboxUrl)
diff --git a/server/lib/activitypub/send/send-reject.ts b/server/lib/activitypub/send/send-reject.ts
new file mode 100644
index 000000000..bac7ff556
--- /dev/null
+++ b/server/lib/activitypub/send/send-reject.ts
@@ -0,0 +1,40 @@
+import { ActivityFollow, ActivityReject } from '../../../../shared/models/activitypub'
+import { ActorModel } from '../../../models/activitypub/actor'
+import { getActorFollowActivityPubUrl, getActorFollowRejectActivityPubUrl } from '../url'
+import { unicastTo } from './utils'
+import { buildFollowActivity } from './send-follow'
+import { logger } from '../../../helpers/logger'
+
+async function sendReject (follower: ActorModel, following: ActorModel) {
+  if (!follower.serverId) { // This should never happen
+    logger.warn('Do not sending reject to local follower.')
+    return
+  }
+
+  logger.info('Creating job to reject follower %s.', follower.url)
+
+  const followUrl = getActorFollowActivityPubUrl(follower, following)
+  const followData = buildFollowActivity(followUrl, follower, following)
+
+  const url = getActorFollowRejectActivityPubUrl(follower, following)
+  const data = buildRejectActivity(url, following, followData)
+
+  return unicastTo(data, following, follower.inboxUrl)
+}
+
+// ---------------------------------------------------------------------------
+
+export {
+  sendReject
+}
+
+// ---------------------------------------------------------------------------
+
+function buildRejectActivity (url: string, byActor: ActorModel, followActivityData: ActivityFollow): ActivityReject {
+  return {
+    type: 'Reject',
+    id: url,
+    actor: byActor.url,
+    object: followActivityData
+  }
+}
diff --git a/server/lib/activitypub/send/send-undo.ts b/server/lib/activitypub/send/send-undo.ts
index bf1b6e117..8727a121e 100644
--- a/server/lib/activitypub/send/send-undo.ts
+++ b/server/lib/activitypub/send/send-undo.ts
@@ -2,7 +2,7 @@ import { Transaction } from 'sequelize'
 import {
   ActivityAnnounce,
   ActivityAudience,
-  ActivityCreate,
+  ActivityCreate, ActivityDislike,
   ActivityFollow,
   ActivityLike,
   ActivityUndo
@@ -13,13 +13,14 @@ import { VideoModel } from '../../../models/video/video'
 import { getActorFollowActivityPubUrl, getUndoActivityPubUrl, getVideoDislikeActivityPubUrl, getVideoLikeActivityPubUrl } from '../url'
 import { broadcastToFollowers, sendVideoRelatedActivity, unicastTo } from './utils'
 import { audiencify, getAudience } from '../audience'
-import { buildCreateActivity, buildDislikeActivity } from './send-create'
+import { buildCreateActivity } from './send-create'
 import { buildFollowActivity } from './send-follow'
 import { buildLikeActivity } from './send-like'
 import { VideoShareModel } from '../../../models/video/video-share'
 import { buildAnnounceWithVideoAudience } from './send-announce'
 import { logger } from '../../../helpers/logger'
 import { VideoRedundancyModel } from '../../../models/redundancy/video-redundancy'
+import { buildDislikeActivity } from './send-dislike'
 
 async function sendUndoFollow (actorFollow: ActorFollowModel, t: Transaction) {
   const me = actorFollow.ActorFollower
@@ -30,7 +31,7 @@ async function sendUndoFollow (actorFollow: ActorFollowModel, t: Transaction) {
 
   logger.info('Creating job to send an unfollow request to %s.', following.url)
 
-  const followUrl = getActorFollowActivityPubUrl(actorFollow)
+  const followUrl = getActorFollowActivityPubUrl(me, following)
   const undoUrl = getUndoActivityPubUrl(followUrl)
 
   const followActivity = buildFollowActivity(followUrl, me, following)
@@ -65,15 +66,15 @@ async function sendUndoDislike (byActor: ActorModel, video: VideoModel, t: Trans
 
   const dislikeUrl = getVideoDislikeActivityPubUrl(byActor, video)
   const dislikeActivity = buildDislikeActivity(dislikeUrl, byActor, video)
-  const createDislikeActivity = buildCreateActivity(dislikeUrl, byActor, dislikeActivity)
 
-  return sendUndoVideoRelatedActivity({ byActor, video, url: dislikeUrl, activity: createDislikeActivity, transaction: t })
+  return sendUndoVideoRelatedActivity({ byActor, video, url: dislikeUrl, activity: dislikeActivity, transaction: t })
 }
 
 async function sendUndoCacheFile (byActor: ActorModel, redundancyModel: VideoRedundancyModel, t: Transaction) {
   logger.info('Creating job to undo cache file %s.', redundancyModel.url)
 
-  const video = await VideoModel.loadAndPopulateAccountAndServerAndTags(redundancyModel.VideoFile.Video.id)
+  const videoId = redundancyModel.getVideo().id
+  const video = await VideoModel.loadAndPopulateAccountAndServerAndTags(videoId)
   const createActivity = buildCreateActivity(redundancyModel.url, byActor, redundancyModel.toActivityPubObject())
 
   return sendUndoVideoRelatedActivity({ byActor, video, url: redundancyModel.url, activity: createActivity, transaction: t })
@@ -94,7 +95,7 @@ export {
 function undoActivityData (
   url: string,
   byActor: ActorModel,
-  object: ActivityFollow | ActivityLike | ActivityCreate | ActivityAnnounce,
+  object: ActivityFollow | ActivityLike | ActivityDislike | ActivityCreate | ActivityAnnounce,
   audience?: ActivityAudience
 ): ActivityUndo {
   if (!audience) audience = getAudience(byActor)
@@ -114,7 +115,7 @@ async function sendUndoVideoRelatedActivity (options: {
   byActor: ActorModel,
   video: VideoModel,
   url: string,
-  activity: ActivityFollow | ActivityLike | ActivityCreate | ActivityAnnounce,
+  activity: ActivityFollow | ActivityLike | ActivityDislike | ActivityCreate | ActivityAnnounce,
   transaction: Transaction
 }) {
   const activityBuilder = (audience: ActivityAudience) => {
diff --git a/server/lib/activitypub/send/send-update.ts b/server/lib/activitypub/send/send-update.ts
index a68f03edf..7411c08d5 100644
--- a/server/lib/activitypub/send/send-update.ts
+++ b/server/lib/activitypub/send/send-update.ts
@@ -12,8 +12,13 @@ import { audiencify, getActorsInvolvedInVideo, getAudience } from '../audience'
 import { logger } from '../../../helpers/logger'
 import { VideoCaptionModel } from '../../../models/video/video-caption'
 import { VideoRedundancyModel } from '../../../models/redundancy/video-redundancy'
+import { VideoPlaylistModel } from '../../../models/video/video-playlist'
+import { VideoPlaylistPrivacy } from '../../../../shared/models/videos/playlist/video-playlist-privacy.model'
+import { getServerActor } from '../../../helpers/utils'
 
 async function sendUpdateVideo (video: VideoModel, t: Transaction, overrodeByActor?: ActorModel) {
+  if (video.privacy === VideoPrivacy.PRIVATE) return undefined
+
   logger.info('Creating job to update video %s.', video.url)
 
   const byActor = overrodeByActor ? overrodeByActor : video.VideoChannel.Account.Actor
@@ -47,7 +52,7 @@ async function sendUpdateActor (accountOrChannel: AccountModel | VideoChannelMod
   let actorsInvolved: ActorModel[]
   if (accountOrChannel instanceof AccountModel) {
     // Actors that shared my videos are involved too
-    actorsInvolved = await VideoShareModel.loadActorsByVideoOwner(byActor.id, t)
+    actorsInvolved = await VideoShareModel.loadActorsWhoSharedVideosOf(byActor.id, t)
   } else {
     // Actors that shared videos of my channel are involved too
     actorsInvolved = await VideoShareModel.loadActorsByVideoChannel(accountOrChannel.id, t)
@@ -61,7 +66,7 @@ async function sendUpdateActor (accountOrChannel: AccountModel | VideoChannelMod
 async function sendUpdateCacheFile (byActor: ActorModel, redundancyModel: VideoRedundancyModel) {
   logger.info('Creating job to update cache file %s.', redundancyModel.url)
 
-  const video = await VideoModel.loadAndPopulateAccountAndServerAndTags(redundancyModel.VideoFile.Video.id)
+  const video = await VideoModel.loadAndPopulateAccountAndServerAndTags(redundancyModel.getVideo().id)
 
   const activityBuilder = (audience: ActivityAudience) => {
     const redundancyObject = redundancyModel.toActivityPubObject()
@@ -73,12 +78,35 @@ async function sendUpdateCacheFile (byActor: ActorModel, redundancyModel: VideoR
   return sendVideoRelatedActivity(activityBuilder, { byActor, video })
 }
 
+async function sendUpdateVideoPlaylist (videoPlaylist: VideoPlaylistModel, t: Transaction) {
+  if (videoPlaylist.privacy === VideoPlaylistPrivacy.PRIVATE) return undefined
+
+  const byActor = videoPlaylist.OwnerAccount.Actor
+
+  logger.info('Creating job to update video playlist %s.', videoPlaylist.url)
+
+  const url = getUpdateActivityPubUrl(videoPlaylist.url, videoPlaylist.updatedAt.toISOString())
+
+  const object = await videoPlaylist.toActivityPubObject(null, t)
+  const audience = getAudience(byActor, videoPlaylist.privacy === VideoPlaylistPrivacy.PUBLIC)
+
+  const updateActivity = buildUpdateActivity(url, byActor, object, audience)
+
+  const serverActor = await getServerActor()
+  const toFollowersOf = [ byActor, serverActor ]
+
+  if (videoPlaylist.VideoChannel) toFollowersOf.push(videoPlaylist.VideoChannel.Actor)
+
+  return broadcastToFollowers(updateActivity, byActor, toFollowersOf, t)
+}
+
 // ---------------------------------------------------------------------------
 
 export {
   sendUpdateActor,
   sendUpdateVideo,
-  sendUpdateCacheFile
+  sendUpdateCacheFile,
+  sendUpdateVideoPlaylist
 }
 
 // ---------------------------------------------------------------------------
diff --git a/server/lib/activitypub/send/send-view.ts b/server/lib/activitypub/send/send-view.ts
new file mode 100644
index 000000000..8ad126be0
--- /dev/null
+++ b/server/lib/activitypub/send/send-view.ts
@@ -0,0 +1,40 @@
+import { Transaction } from 'sequelize'
+import { ActivityAudience, ActivityView } from '../../../../shared/models/activitypub'
+import { ActorModel } from '../../../models/activitypub/actor'
+import { VideoModel } from '../../../models/video/video'
+import { getVideoLikeActivityPubUrl } from '../url'
+import { sendVideoRelatedActivity } from './utils'
+import { audiencify, getAudience } from '../audience'
+import { logger } from '../../../helpers/logger'
+
+async function sendView (byActor: ActorModel, video: VideoModel, t: Transaction) {
+  logger.info('Creating job to send view of %s.', video.url)
+
+  const activityBuilder = (audience: ActivityAudience) => {
+    const url = getVideoLikeActivityPubUrl(byActor, video)
+
+    return buildViewActivity(url, byActor, video, audience)
+  }
+
+  return sendVideoRelatedActivity(activityBuilder, { byActor, video, transaction: t })
+}
+
+function buildViewActivity (url: string, byActor: ActorModel, video: VideoModel, audience?: ActivityAudience): ActivityView {
+  if (!audience) audience = getAudience(byActor)
+
+  return audiencify(
+    {
+      id: url,
+      type: 'View' as 'View',
+      actor: byActor.url,
+      object: video.url
+    },
+    audience
+  )
+}
+
+// ---------------------------------------------------------------------------
+
+export {
+  sendView
+}
diff --git a/server/lib/activitypub/share.ts b/server/lib/activitypub/share.ts
index 1767df0ae..7f38402b6 100644
--- a/server/lib/activitypub/share.ts
+++ b/server/lib/activitypub/share.ts
@@ -10,7 +10,7 @@ import * as Bluebird from 'bluebird'
 import { doRequest } from '../../helpers/requests'
 import { getOrCreateActorAndServerAndModel } from './actor'
 import { logger } from '../../helpers/logger'
-import { CRAWL_REQUEST_CONCURRENCY } from '../../initializers'
+import { CRAWL_REQUEST_CONCURRENCY } from '../../initializers/constants'
 import { checkUrlsSameHost, getAPId } from '../../helpers/activitypub'
 
 async function shareVideoByServerAndChannel (video: VideoModel, t: Transaction) {
@@ -54,12 +54,7 @@ async function addVideoShares (shareUrls: string[], instance: VideoModel) {
         url: shareUrl
       }
 
-      await VideoShareModel.findOrCreate({
-        where: {
-          url: shareUrl
-        },
-        defaults: entry
-      })
+      await VideoShareModel.upsert(entry)
     } catch (err) {
       logger.warn('Cannot add share %s.', shareUrl, { err })
     }
diff --git a/server/lib/activitypub/url.ts b/server/lib/activitypub/url.ts
index 38f15448c..bcb7a4ee2 100644
--- a/server/lib/activitypub/url.ts
+++ b/server/lib/activitypub/url.ts
@@ -1,35 +1,49 @@
-import { CONFIG } from '../../initializers'
+import { WEBSERVER } from '../../initializers/constants'
 import { ActorModel } from '../../models/activitypub/actor'
 import { ActorFollowModel } from '../../models/activitypub/actor-follow'
 import { VideoModel } from '../../models/video/video'
 import { VideoAbuseModel } from '../../models/video/video-abuse'
 import { VideoCommentModel } from '../../models/video/video-comment'
 import { VideoFileModel } from '../../models/video/video-file'
+import { VideoStreamingPlaylistModel } from '../../models/video/video-streaming-playlist'
+import { VideoPlaylistModel } from '../../models/video/video-playlist'
 
 function getVideoActivityPubUrl (video: VideoModel) {
-  return CONFIG.WEBSERVER.URL + '/videos/watch/' + video.uuid
+  return WEBSERVER.URL + '/videos/watch/' + video.uuid
+}
+
+function getVideoPlaylistActivityPubUrl (videoPlaylist: VideoPlaylistModel) {
+  return WEBSERVER.URL + '/video-playlists/' + videoPlaylist.uuid
+}
+
+function getVideoPlaylistElementActivityPubUrl (videoPlaylist: VideoPlaylistModel, video: VideoModel) {
+  return WEBSERVER.URL + '/video-playlists/' + videoPlaylist.uuid + '/' + video.uuid
 }
 
 function getVideoCacheFileActivityPubUrl (videoFile: VideoFileModel) {
   const suffixFPS = videoFile.fps && videoFile.fps !== -1 ? '-' + videoFile.fps : ''
 
-  return `${CONFIG.WEBSERVER.URL}/redundancy/videos/${videoFile.Video.uuid}/${videoFile.resolution}${suffixFPS}`
+  return `${WEBSERVER.URL}/redundancy/videos/${videoFile.Video.uuid}/${videoFile.resolution}${suffixFPS}`
+}
+
+function getVideoCacheStreamingPlaylistActivityPubUrl (video: VideoModel, playlist: VideoStreamingPlaylistModel) {
+  return `${WEBSERVER.URL}/redundancy/streaming-playlists/${playlist.getStringType()}/${video.uuid}`
 }
 
 function getVideoCommentActivityPubUrl (video: VideoModel, videoComment: VideoCommentModel) {
-  return CONFIG.WEBSERVER.URL + '/videos/watch/' + video.uuid + '/comments/' + videoComment.id
+  return WEBSERVER.URL + '/videos/watch/' + video.uuid + '/comments/' + videoComment.id
 }
 
 function getVideoChannelActivityPubUrl (videoChannelName: string) {
-  return CONFIG.WEBSERVER.URL + '/video-channels/' + videoChannelName
+  return WEBSERVER.URL + '/video-channels/' + videoChannelName
 }
 
 function getAccountActivityPubUrl (accountName: string) {
-  return CONFIG.WEBSERVER.URL + '/accounts/' + accountName
+  return WEBSERVER.URL + '/accounts/' + accountName
 }
 
 function getVideoAbuseActivityPubUrl (videoAbuse: VideoAbuseModel) {
-  return CONFIG.WEBSERVER.URL + '/admin/video-abuses/' + videoAbuse.id
+  return WEBSERVER.URL + '/admin/video-abuses/' + videoAbuse.id
 }
 
 function getVideoViewActivityPubUrl (byActor: ActorModel, video: VideoModel) {
@@ -60,11 +74,8 @@ function getVideoDislikesActivityPubUrl (video: VideoModel) {
   return video.url + '/dislikes'
 }
 
-function getActorFollowActivityPubUrl (actorFollow: ActorFollowModel) {
-  const me = actorFollow.ActorFollower
-  const following = actorFollow.ActorFollowing
-
-  return me.url + '/follows/' + following.id
+function getActorFollowActivityPubUrl (follower: ActorModel, following: ActorModel) {
+  return follower.url + '/follows/' + following.id
 }
 
 function getActorFollowAcceptActivityPubUrl (actorFollow: ActorFollowModel) {
@@ -74,6 +85,10 @@ function getActorFollowAcceptActivityPubUrl (actorFollow: ActorFollowModel) {
   return follower.url + '/accepts/follows/' + me.id
 }
 
+function getActorFollowRejectActivityPubUrl (follower: ActorModel, following: ActorModel) {
+  return follower.url + '/rejects/follows/' + following.id
+}
+
 function getVideoAnnounceActivityPubUrl (byActor: ActorModel, video: VideoModel) {
   return video.url + '/announces/' + byActor.id
 }
@@ -92,6 +107,9 @@ function getUndoActivityPubUrl (originalUrl: string) {
 
 export {
   getVideoActivityPubUrl,
+  getVideoPlaylistElementActivityPubUrl,
+  getVideoPlaylistActivityPubUrl,
+  getVideoCacheStreamingPlaylistActivityPubUrl,
   getVideoChannelActivityPubUrl,
   getAccountActivityPubUrl,
   getVideoAbuseActivityPubUrl,
@@ -103,6 +121,7 @@ export {
   getVideoViewActivityPubUrl,
   getVideoLikeActivityPubUrl,
   getVideoDislikeActivityPubUrl,
+  getActorFollowRejectActivityPubUrl,
   getVideoCommentActivityPubUrl,
   getDeleteActivityPubUrl,
   getVideoSharesActivityPubUrl,
diff --git a/server/lib/activitypub/video-comments.ts b/server/lib/activitypub/video-comments.ts
index e87301fe7..18f44d50e 100644
--- a/server/lib/activitypub/video-comments.ts
+++ b/server/lib/activitypub/video-comments.ts
@@ -2,7 +2,7 @@ import { VideoCommentObject } from '../../../shared/models/activitypub/objects/v
 import { sanitizeAndCheckVideoCommentObject } from '../../helpers/custom-validators/activitypub/video-comments'
 import { logger } from '../../helpers/logger'
 import { doRequest } from '../../helpers/requests'
-import { ACTIVITY_PUB, CRAWL_REQUEST_CONCURRENCY } from '../../initializers'
+import { ACTIVITY_PUB, CRAWL_REQUEST_CONCURRENCY } from '../../initializers/constants'
 import { ActorModel } from '../../models/activitypub/actor'
 import { VideoModel } from '../../models/video/video'
 import { VideoCommentModel } from '../../models/video/video-comment'
@@ -34,8 +34,7 @@ async function videoCommentActivityObjectToDBAttributes (video: VideoModel, acto
     accountId: actor.Account.id,
     inReplyToCommentId,
     originCommentId,
-    createdAt: new Date(comment.published),
-    updatedAt: new Date(comment.updated)
+    createdAt: new Date(comment.published)
   }
 }
 
@@ -74,12 +73,7 @@ async function addVideoComment (videoInstance: VideoModel, commentUrl: string) {
   const entry = await videoCommentActivityObjectToDBAttributes(videoInstance, actor, body)
   if (!entry) return { created: false }
 
-  const [ comment, created ] = await VideoCommentModel.findOrCreate({
-    where: {
-      url: body.id
-    },
-    defaults: entry
-  })
+  const [ comment, created ] = await VideoCommentModel.upsert<VideoCommentModel>(entry, { returning: true })
   comment.Account = actor.Account
   comment.Video = videoInstance
 
diff --git a/server/lib/activitypub/video-rates.ts b/server/lib/activitypub/video-rates.ts
index 45a2b22ea..cda5b2981 100644
--- a/server/lib/activitypub/video-rates.ts
+++ b/server/lib/activitypub/video-rates.ts
@@ -1,17 +1,18 @@
 import { Transaction } from 'sequelize'
 import { AccountModel } from '../../models/account/account'
 import { VideoModel } from '../../models/video/video'
-import { sendCreateDislike, sendLike, sendUndoDislike, sendUndoLike } from './send'
+import { sendLike, sendUndoDislike, sendUndoLike } from './send'
 import { VideoRateType } from '../../../shared/models/videos'
 import * as Bluebird from 'bluebird'
 import { getOrCreateActorAndServerAndModel } from './actor'
 import { AccountVideoRateModel } from '../../models/account/account-video-rate'
 import { logger } from '../../helpers/logger'
-import { CRAWL_REQUEST_CONCURRENCY } from '../../initializers'
+import { CRAWL_REQUEST_CONCURRENCY } from '../../initializers/constants'
 import { doRequest } from '../../helpers/requests'
 import { checkUrlsSameHost, getAPId } from '../../helpers/activitypub'
 import { ActorModel } from '../../models/activitypub/actor'
 import { getVideoDislikeActivityPubUrl, getVideoLikeActivityPubUrl } from './url'
+import { sendDislike } from './send/send-dislike'
 
 async function createRates (ratesUrl: string[], video: VideoModel, rate: VideoRateType) {
   let rateCounts = 0
@@ -37,19 +38,14 @@ async function createRates (ratesUrl: string[], video: VideoModel, rate: VideoRa
 
       const actor = await getOrCreateActorAndServerAndModel(actorUrl)
 
-      const [ , created ] = await AccountVideoRateModel
-        .findOrCreate({
-          where: {
-            videoId: video.id,
-            accountId: actor.Account.id
-          },
-          defaults: {
-            videoId: video.id,
-            accountId: actor.Account.id,
-            type: rate,
-            url: body.id
-          }
-        })
+      const entry = {
+        videoId: video.id,
+        accountId: actor.Account.id,
+        type: rate,
+        url: body.id
+      }
+
+      const created = await AccountVideoRateModel.upsert(entry)
 
       if (created) rateCounts += 1
     } catch (err) {
@@ -60,7 +56,10 @@ async function createRates (ratesUrl: string[], video: VideoModel, rate: VideoRa
   logger.info('Adding %d %s to video %s.', rateCounts, rate, video.uuid)
 
   // This is "likes" and "dislikes"
-  if (rateCounts !== 0) await video.increment(rate + 's', { by: rateCounts })
+  if (rateCounts !== 0) {
+    const field = rate === 'like' ? 'likes' : 'dislikes'
+    await video.increment(field, { by: rateCounts })
+  }
 
   return
 }
@@ -82,7 +81,7 @@ async function sendVideoRateChange (account: AccountModel,
   // Like
   if (likes > 0) await sendLike(actor, video, t)
   // Dislike
-  if (dislikes > 0) await sendCreateDislike(actor, video, t)
+  if (dislikes > 0) await sendDislike(actor, video, t)
 }
 
 function getRateUrl (rateType: VideoRateType, actor: ActorModel, video: VideoModel) {
diff --git a/server/lib/activitypub/videos.ts b/server/lib/activitypub/videos.ts
index e1e523499..4f26cb6be 100644
--- a/server/lib/activitypub/videos.ts
+++ b/server/lib/activitypub/videos.ts
@@ -2,15 +2,28 @@ import * as Bluebird from 'bluebird'
 import * as sequelize from 'sequelize'
 import * as magnetUtil from 'magnet-uri'
 import * as request from 'request'
-import { ActivityIconObject, ActivityUrlObject, ActivityVideoUrlObject, VideoState } from '../../../shared/index'
+import {
+  ActivityPlaylistSegmentHashesObject,
+  ActivityPlaylistUrlObject,
+  ActivityUrlObject,
+  ActivityVideoUrlObject,
+  VideoState
+} from '../../../shared/index'
 import { VideoTorrentObject } from '../../../shared/models/activitypub/objects'
 import { VideoPrivacy } from '../../../shared/models/videos'
 import { sanitizeAndCheckVideoTorrentObject } from '../../helpers/custom-validators/activitypub/videos'
 import { isVideoFileInfoHashValid } from '../../helpers/custom-validators/videos'
 import { resetSequelizeInstance, retryTransactionWrapper } from '../../helpers/database-utils'
 import { logger } from '../../helpers/logger'
-import { doRequest, downloadImage } from '../../helpers/requests'
-import { ACTIVITY_PUB, CONFIG, MIMETYPES, REMOTE_SCHEME, sequelizeTypescript, THUMBNAILS_SIZE } from '../../initializers'
+import { doRequest, doRequestAndSaveToFile } from '../../helpers/requests'
+import {
+  ACTIVITY_PUB,
+  MIMETYPES,
+  P2P_MEDIA_LOADER_PEER_VERSION,
+  PREVIEWS_SIZE,
+  REMOTE_SCHEME,
+  STATIC_PATHS
+} from '../../initializers/constants'
 import { ActorModel } from '../../models/activitypub/actor'
 import { TagModel } from '../../models/video/tag'
 import { VideoModel } from '../../models/video/video'
@@ -30,9 +43,20 @@ import { AccountModel } from '../../models/account/account'
 import { fetchVideoByUrl, VideoFetchByUrlType } from '../../helpers/video'
 import { checkUrlsSameHost, getAPId } from '../../helpers/activitypub'
 import { Notifier } from '../notifier'
+import { VideoStreamingPlaylistModel } from '../../models/video/video-streaming-playlist'
+import { VideoStreamingPlaylistType } from '../../../shared/models/videos/video-streaming-playlist.type'
+import { AccountVideoRateModel } from '../../models/account/account-video-rate'
+import { VideoShareModel } from '../../models/video/video-share'
+import { VideoCommentModel } from '../../models/video/video-comment'
+import { sequelizeTypescript } from '../../initializers/database'
+import { createPlaceholderThumbnail, createVideoMiniatureFromUrl } from '../thumbnail'
+import { ThumbnailModel } from '../../models/video/thumbnail'
+import { ThumbnailType } from '../../../shared/models/videos/thumbnail.type'
+import { join } from 'path'
+import { FilteredModelAttributes } from '../../typings/sequelize'
 
 async function federateVideoIfNeeded (video: VideoModel, isNewVideo: boolean, transaction?: sequelize.Transaction) {
-  // If the video is not private and published, we federate it
+  // If the video is not private and is published, we federate it
   if (video.privacy !== VideoPrivacy.PRIVATE && video.state === VideoState.PUBLISHED) {
     // Fetch more attributes that we will need to serialize in AP object
     if (isArray(video.VideoCaptions) === false) {
@@ -84,19 +108,17 @@ async function fetchRemoteVideoDescription (video: VideoModel) {
   return body.description ? body.description : ''
 }
 
-function fetchRemoteVideoStaticFile (video: VideoModel, path: string, reject: Function) {
-  const host = video.VideoChannel.Account.Actor.Server.host
+function fetchRemoteVideoStaticFile (video: VideoModel, path: string, destPath: string) {
+  const url = buildRemoteBaseUrl(video, path)
 
   // We need to provide a callback, if no we could have an uncaught exception
-  return request.get(REMOTE_SCHEME.HTTP + '://' + host + path, err => {
-    if (err) reject(err)
-  })
+  return doRequestAndSaveToFile({ uri: url }, destPath)
 }
 
-function generateThumbnailFromUrl (video: VideoModel, icon: ActivityIconObject) {
-  const thumbnailName = video.getThumbnailName()
+function buildRemoteBaseUrl (video: VideoModel, path: string) {
+  const host = video.VideoChannel.Account.Actor.Server.host
 
-  return downloadImage(icon.url, CONFIG.STORAGE.THUMBNAILS_DIR, thumbnailName, THUMBNAILS_SIZE)
+  return REMOTE_SCHEME.HTTP + '://' + host + path
 }
 
 function getOrCreateVideoChannelFromVideoObject (videoObject: VideoTorrentObject) {
@@ -124,31 +146,43 @@ async function syncVideoExternalAttributes (video: VideoModel, fetchedVideo: Vid
   const jobPayloads: ActivitypubHttpFetcherPayload[] = []
 
   if (syncParam.likes === true) {
-    await crawlCollectionPage<string>(fetchedVideo.likes, items => createRates(items, video, 'like'))
+    const handler = items => createRates(items, video, 'like')
+    const cleaner = crawlStartDate => AccountVideoRateModel.cleanOldRatesOf(video.id, 'like' as 'like', crawlStartDate)
+
+    await crawlCollectionPage<string>(fetchedVideo.likes, handler, cleaner)
       .catch(err => logger.error('Cannot add likes of video %s.', video.uuid, { err }))
   } else {
     jobPayloads.push({ uri: fetchedVideo.likes, videoId: video.id, type: 'video-likes' as 'video-likes' })
   }
 
   if (syncParam.dislikes === true) {
-    await crawlCollectionPage<string>(fetchedVideo.dislikes, items => createRates(items, video, 'dislike'))
+    const handler = items => createRates(items, video, 'dislike')
+    const cleaner = crawlStartDate => AccountVideoRateModel.cleanOldRatesOf(video.id, 'dislike' as 'dislike', crawlStartDate)
+
+    await crawlCollectionPage<string>(fetchedVideo.dislikes, handler, cleaner)
       .catch(err => logger.error('Cannot add dislikes of video %s.', video.uuid, { err }))
   } else {
     jobPayloads.push({ uri: fetchedVideo.dislikes, videoId: video.id, type: 'video-dislikes' as 'video-dislikes' })
   }
 
   if (syncParam.shares === true) {
-    await crawlCollectionPage<string>(fetchedVideo.shares, items => addVideoShares(items, video))
+    const handler = items => addVideoShares(items, video)
+    const cleaner = crawlStartDate => VideoShareModel.cleanOldSharesOf(video.id, crawlStartDate)
+
+    await crawlCollectionPage<string>(fetchedVideo.shares, handler, cleaner)
       .catch(err => logger.error('Cannot add shares of video %s.', video.uuid, { err }))
   } else {
     jobPayloads.push({ uri: fetchedVideo.shares, videoId: video.id, type: 'video-shares' as 'video-shares' })
   }
 
   if (syncParam.comments === true) {
-    await crawlCollectionPage<string>(fetchedVideo.comments, items => addVideoComments(items, video))
+    const handler = items => addVideoComments(items, video)
+    const cleaner = crawlStartDate => VideoCommentModel.cleanOldCommentsOf(video.id, crawlStartDate)
+
+    await crawlCollectionPage<string>(fetchedVideo.comments, handler, cleaner)
       .catch(err => logger.error('Cannot add comments of video %s.', video.uuid, { err }))
   } else {
-    jobPayloads.push({ uri: fetchedVideo.shares, videoId: video.id, type: 'video-shares' as 'video-shares' })
+    jobPayloads.push({ uri: fetchedVideo.comments, videoId: video.id, type: 'video-comments' as 'video-comments' })
   }
 
   await Bluebird.map(jobPayloads, payload => JobQueue.Instance.createJob({ type: 'activitypub-http-fetcher', payload }))
@@ -170,8 +204,7 @@ async function getOrCreateVideoAndAccountAndChannel (options: {
 
   let videoFromDatabase = await fetchVideoByUrl(videoUrl, fetchType)
   if (videoFromDatabase) {
-
-    if (allowRefresh === true) {
+    if (videoFromDatabase.isOutdated() && allowRefresh === true) {
       const refreshOptions = {
         video: videoFromDatabase,
         fetchedType: fetchType,
@@ -210,6 +243,14 @@ async function updateVideoFromAP (options: {
   const wasUnlistedVideo = options.video.privacy === VideoPrivacy.UNLISTED
 
   try {
+    let thumbnailModel: ThumbnailModel
+
+    try {
+      thumbnailModel = await createVideoMiniatureFromUrl(options.videoObject.icon.url, options.video, ThumbnailType.MINIATURE)
+    } catch (err) {
+      logger.warn('Cannot generate thumbnail of %s.', options.videoObject.id, { err })
+    }
+
     await sequelizeTypescript.transaction(async t => {
       const sequelizeOptions = { transaction: t }
 
@@ -233,17 +274,26 @@ async function updateVideoFromAP (options: {
       options.video.set('support', videoData.support)
       options.video.set('nsfw', videoData.nsfw)
       options.video.set('commentsEnabled', videoData.commentsEnabled)
+      options.video.set('downloadEnabled', videoData.downloadEnabled)
       options.video.set('waitTranscoding', videoData.waitTranscoding)
       options.video.set('state', videoData.state)
       options.video.set('duration', videoData.duration)
       options.video.set('createdAt', videoData.createdAt)
       options.video.set('publishedAt', videoData.publishedAt)
+      options.video.set('originallyPublishedAt', videoData.originallyPublishedAt)
       options.video.set('privacy', videoData.privacy)
       options.video.set('channelId', videoData.channelId)
       options.video.set('views', videoData.views)
 
       await options.video.save(sequelizeOptions)
 
+      if (thumbnailModel) if (thumbnailModel) await options.video.addAndSaveThumbnail(thumbnailModel, t)
+
+      // FIXME: use icon URL instead
+      const previewUrl = buildRemoteBaseUrl(options.video, join(STATIC_PATHS.PREVIEWS, options.video.getPreview().filename))
+      const previewModel = createPlaceholderThumbnail(previewUrl, options.video, ThumbnailType.PREVIEW, PREVIEWS_SIZE)
+      await options.video.addAndSaveThumbnail(previewModel, t)
+
       {
         const videoFileAttributes = videoFileActivityUrlToDBAttributes(options.video, options.videoObject)
         const newVideoFiles = videoFileAttributes.map(a => new VideoFileModel(a))
@@ -264,6 +314,29 @@ async function updateVideoFromAP (options: {
       }
 
       {
+        const streamingPlaylistAttributes = streamingPlaylistActivityUrlToDBAttributes(
+          options.video,
+          options.videoObject,
+          options.video.VideoFiles
+        )
+        const newStreamingPlaylists = streamingPlaylistAttributes.map(a => new VideoStreamingPlaylistModel(a))
+
+        // Remove video files that do not exist anymore
+        const destroyTasks = options.video.VideoStreamingPlaylists
+                                    .filter(f => !newStreamingPlaylists.find(newPlaylist => newPlaylist.hasSameUniqueKeysThan(f)))
+                                    .map(f => f.destroy(sequelizeOptions))
+        await Promise.all(destroyTasks)
+
+        // Update or add other one
+        const upsertTasks = streamingPlaylistAttributes.map(a => {
+          return VideoStreamingPlaylistModel.upsert<VideoStreamingPlaylistModel>(a, { returning: true, transaction: t })
+                               .then(([ streamingPlaylist ]) => streamingPlaylist)
+        })
+
+        options.video.VideoStreamingPlaylists = await Promise.all(upsertTasks)
+      }
+
+      {
         // Update Tags
         const tags = options.videoObject.tag.map(tag => tag.name)
         const tagInstances = await TagModel.findOrCreateTags(tags, t)
@@ -296,12 +369,6 @@ async function updateVideoFromAP (options: {
     logger.debug('Cannot update the remote video.', { err })
     throw err
   }
-
-  try {
-    await generateThumbnailFromUrl(options.video, options.videoObject.icon)
-  } catch (err) {
-    logger.warn('Cannot generate thumbnail of %s.', options.videoObject.id, { err })
-  }
 }
 
 async function refreshVideoIfNeeded (options: {
@@ -361,29 +428,55 @@ export {
   getOrCreateVideoAndAccountAndChannel,
   fetchRemoteVideoStaticFile,
   fetchRemoteVideoDescription,
-  generateThumbnailFromUrl,
   getOrCreateVideoChannelFromVideoObject
 }
 
 // ---------------------------------------------------------------------------
 
-function isActivityVideoUrlObject (url: ActivityUrlObject): url is ActivityVideoUrlObject {
+function isAPVideoUrlObject (url: ActivityUrlObject): url is ActivityVideoUrlObject {
   const mimeTypes = Object.keys(MIMETYPES.VIDEO.MIMETYPE_EXT)
 
   const urlMediaType = url.mediaType || url.mimeType
   return mimeTypes.indexOf(urlMediaType) !== -1 && urlMediaType.startsWith('video/')
 }
 
+function isAPStreamingPlaylistUrlObject (url: ActivityUrlObject): url is ActivityPlaylistUrlObject {
+  const urlMediaType = url.mediaType || url.mimeType
+
+  return urlMediaType === 'application/x-mpegURL'
+}
+
+function isAPPlaylistSegmentHashesUrlObject (tag: any): tag is ActivityPlaylistSegmentHashesObject {
+  const urlMediaType = tag.mediaType || tag.mimeType
+
+  return tag.name === 'sha256' && tag.type === 'Link' && urlMediaType === 'application/json'
+}
+
 async function createVideo (videoObject: VideoTorrentObject, channelActor: ActorModel, waitThumbnail = false) {
   logger.debug('Adding remote video %s.', videoObject.id)
 
+  const videoData = await videoActivityObjectToDBAttributes(channelActor.VideoChannel, videoObject, videoObject.to)
+  const video = VideoModel.build(videoData)
+
+  const promiseThumbnail = createVideoMiniatureFromUrl(videoObject.icon.url, video, ThumbnailType.MINIATURE)
+
+  let thumbnailModel: ThumbnailModel
+  if (waitThumbnail === true) {
+    thumbnailModel = await promiseThumbnail
+  }
+
   const videoCreated: VideoModel = await sequelizeTypescript.transaction(async t => {
     const sequelizeOptions = { transaction: t }
 
-    const videoData = await videoActivityObjectToDBAttributes(channelActor.VideoChannel, videoObject, videoObject.to)
-    const video = VideoModel.build(videoData)
-
     const videoCreated = await video.save(sequelizeOptions)
+    videoCreated.VideoChannel = channelActor.VideoChannel
+
+    if (thumbnailModel) await videoCreated.addAndSaveThumbnail(thumbnailModel, t)
+
+    // FIXME: use icon URL instead
+    const previewUrl = buildRemoteBaseUrl(videoCreated, join(STATIC_PATHS.PREVIEWS, video.generatePreviewName()))
+    const previewModel = createPlaceholderThumbnail(previewUrl, video, ThumbnailType.PREVIEW, PREVIEWS_SIZE)
+    if (thumbnailModel) await videoCreated.addAndSaveThumbnail(previewModel, t)
 
     // Process files
     const videoFileAttributes = videoFileActivityUrlToDBAttributes(videoCreated, videoObject)
@@ -392,10 +485,16 @@ async function createVideo (videoObject: VideoTorrentObject, channelActor: Actor
     }
 
     const videoFilePromises = videoFileAttributes.map(f => VideoFileModel.create(f, { transaction: t }))
-    await Promise.all(videoFilePromises)
+    const videoFiles = await Promise.all(videoFilePromises)
+
+    const videoStreamingPlaylists = streamingPlaylistActivityUrlToDBAttributes(videoCreated, videoObject, videoFiles)
+    const playlistPromises = videoStreamingPlaylists.map(p => VideoStreamingPlaylistModel.create(p, { transaction: t }))
+    await Promise.all(playlistPromises)
 
     // Process tags
-    const tags = videoObject.tag.map(t => t.name)
+    const tags = videoObject.tag
+                            .filter(t => t.type === 'Hashtag')
+                            .map(t => t.name)
     const tagInstances = await TagModel.findOrCreateTags(tags, t)
     await videoCreated.$set('Tags', tagInstances, sequelizeOptions)
 
@@ -407,14 +506,16 @@ async function createVideo (videoObject: VideoTorrentObject, channelActor: Actor
 
     logger.info('Remote video with uuid %s inserted.', videoObject.uuid)
 
-    videoCreated.VideoChannel = channelActor.VideoChannel
     return videoCreated
   })
 
-  const p = generateThumbnailFromUrl(videoCreated, videoObject.icon)
-    .catch(err => logger.warn('Cannot generate thumbnail of %s.', videoObject.id, { err }))
+  if (waitThumbnail === false) {
+    promiseThumbnail.then(thumbnailModel => {
+      thumbnailModel = videoCreated.id
 
-  if (waitThumbnail === true) await p
+      return thumbnailModel.save()
+    })
+  }
 
   return videoCreated
 }
@@ -456,12 +557,14 @@ async function videoActivityObjectToDBAttributes (
     support,
     nsfw: videoObject.sensitive,
     commentsEnabled: videoObject.commentsEnabled,
+    downloadEnabled: videoObject.downloadEnabled,
     waitTranscoding: videoObject.waitTranscoding,
     state: videoObject.state,
     channelId: videoChannel.id,
     duration: parseInt(duration, 10),
     createdAt: new Date(videoObject.published),
     publishedAt: new Date(videoObject.published),
+    originallyPublishedAt: videoObject.originallyPublishedAt ? new Date(videoObject.originallyPublishedAt) : null,
     // FIXME: updatedAt does not seems to be considered by Sequelize
     updatedAt: new Date(videoObject.updated),
     views: videoObject.views,
@@ -473,13 +576,13 @@ async function videoActivityObjectToDBAttributes (
 }
 
 function videoFileActivityUrlToDBAttributes (video: VideoModel, videoObject: VideoTorrentObject) {
-  const fileUrls = videoObject.url.filter(u => isActivityVideoUrlObject(u)) as ActivityVideoUrlObject[]
+  const fileUrls = videoObject.url.filter(u => isAPVideoUrlObject(u)) as ActivityVideoUrlObject[]
 
   if (fileUrls.length === 0) {
     throw new Error('Cannot find video files for ' + video.url)
   }
 
-  const attributes: VideoFileModel[] = []
+  const attributes: FilteredModelAttributes<VideoFileModel>[] = []
   for (const fileUrl of fileUrls) {
     // Fetch associated magnet uri
     const magnet = videoObject.url.find(u => {
@@ -502,7 +605,38 @@ function videoFileActivityUrlToDBAttributes (video: VideoModel, videoObject: Vid
       size: fileUrl.size,
       videoId: video.id,
       fps: fileUrl.fps || -1
-    } as VideoFileModel
+    }
+
+    attributes.push(attribute)
+  }
+
+  return attributes
+}
+
+function streamingPlaylistActivityUrlToDBAttributes (video: VideoModel, videoObject: VideoTorrentObject, videoFiles: VideoFileModel[]) {
+  const playlistUrls = videoObject.url.filter(u => isAPStreamingPlaylistUrlObject(u)) as ActivityPlaylistUrlObject[]
+  if (playlistUrls.length === 0) return []
+
+  const attributes: FilteredModelAttributes<VideoStreamingPlaylistModel>[] = []
+  for (const playlistUrlObject of playlistUrls) {
+    const segmentsSha256UrlObject = playlistUrlObject.tag
+                                                     .find(t => {
+                                                       return isAPPlaylistSegmentHashesUrlObject(t)
+                                                     }) as ActivityPlaylistSegmentHashesObject
+    if (!segmentsSha256UrlObject) {
+      logger.warn('No segment sha256 URL found in AP playlist object.', { playlistUrl: playlistUrlObject })
+      continue
+    }
+
+    const attribute = {
+      type: VideoStreamingPlaylistType.HLS,
+      playlistUrl: playlistUrlObject.href,
+      segmentsSha256Url: segmentsSha256UrlObject.href,
+      p2pMediaLoaderInfohashes: VideoStreamingPlaylistModel.buildP2PMediaLoaderInfoHashes(playlistUrlObject.href, videoFiles),
+      p2pMediaLoaderPeerVersion: P2P_MEDIA_LOADER_PEER_VERSION,
+      videoId: video.id
+    }
+
     attributes.push(attribute)
   }
 
diff --git a/server/lib/avatar.ts b/server/lib/avatar.ts
index 021426a1a..09b4e38ca 100644
--- a/server/lib/avatar.ts
+++ b/server/lib/avatar.ts
@@ -1,6 +1,6 @@
 import 'multer'
 import { sendUpdateActor } from './activitypub/send'
-import { AVATARS_SIZE, CONFIG, sequelizeTypescript } from '../initializers'
+import { AVATARS_SIZE } from '../initializers/constants'
 import { updateActorAvatarInstance } from './activitypub'
 import { processImage } from '../helpers/image-utils'
 import { AccountModel } from '../models/account/account'
@@ -8,12 +8,14 @@ import { VideoChannelModel } from '../models/video/video-channel'
 import { extname, join } from 'path'
 import { retryTransactionWrapper } from '../helpers/database-utils'
 import * as uuidv4 from 'uuid/v4'
+import { CONFIG } from '../initializers/config'
+import { sequelizeTypescript } from '../initializers/database'
 
 async function updateActorAvatarFile (avatarPhysicalFile: Express.Multer.File, accountOrChannel: AccountModel | VideoChannelModel) {
   const extension = extname(avatarPhysicalFile.filename)
   const avatarName = uuidv4() + extension
   const destination = join(CONFIG.STORAGE.AVATARS_DIR, avatarName)
-  await processImage(avatarPhysicalFile, destination, AVATARS_SIZE)
+  await processImage(avatarPhysicalFile.path, destination, AVATARS_SIZE)
 
   return retryTransactionWrapper(() => {
     return sequelizeTypescript.transaction(async t => {
diff --git a/server/lib/cache/abstract-video-static-file-cache.ts b/server/lib/cache/abstract-video-static-file-cache.ts
deleted file mode 100644
index 7512f2b9d..000000000
--- a/server/lib/cache/abstract-video-static-file-cache.ts
+++ /dev/null
@@ -1,52 +0,0 @@
-import * as AsyncLRU from 'async-lru'
-import { createWriteStream, remove } from 'fs-extra'
-import { logger } from '../../helpers/logger'
-import { VideoModel } from '../../models/video/video'
-import { fetchRemoteVideoStaticFile } from '../activitypub'
-
-export abstract class AbstractVideoStaticFileCache <T> {
-
-  protected lru
-
-  abstract getFilePath (params: T): Promise<string>
-
-  // Load and save the remote file, then return the local path from filesystem
-  protected abstract loadRemoteFile (key: string): Promise<string>
-
-  init (max: number, maxAge: number) {
-    this.lru = new AsyncLRU({
-      max,
-      maxAge,
-      load: (key, cb) => {
-        this.loadRemoteFile(key)
-          .then(res => cb(null, res))
-          .catch(err => cb(err))
-      }
-    })
-
-    this.lru.on('evict', (obj: { key: string, value: string }) => {
-      remove(obj.value)
-        .then(() => logger.debug('%s evicted from %s', obj.value, this.constructor.name))
-    })
-  }
-
-  protected loadFromLRU (key: string) {
-    return new Promise<string>((res, rej) => {
-      this.lru.get(key, (err, value) => {
-        err ? rej(err) : res(value)
-      })
-    })
-  }
-
-  protected saveRemoteVideoFileAndReturnPath (video: VideoModel, remoteStaticPath: string, destPath: string) {
-    return new Promise<string>((res, rej) => {
-      const req = fetchRemoteVideoStaticFile(video, remoteStaticPath, rej)
-
-      const stream = createWriteStream(destPath)
-
-      req.pipe(stream)
-         .on('error', (err) => rej(err))
-         .on('finish', () => res(destPath))
-    })
-  }
-}
diff --git a/server/lib/client-html.ts b/server/lib/client-html.ts
index b2c376e20..516827a05 100644
--- a/server/lib/client-html.ts
+++ b/server/lib/client-html.ts
@@ -1,7 +1,6 @@
 import * as express from 'express'
-import * as Bluebird from 'bluebird'
 import { buildFileLocale, getDefaultLocale, is18nLocale, POSSIBLE_LOCALES } from '../../shared/models/i18n/i18n'
-import { CONFIG, CUSTOM_HTML_TAG_COMMENTS, EMBED_SIZE } from '../initializers'
+import { CUSTOM_HTML_TAG_COMMENTS, EMBED_SIZE, WEBSERVER } from '../initializers/constants'
 import { join } from 'path'
 import { escapeHTML } from '../helpers/core-utils'
 import { VideoModel } from '../models/video/video'
@@ -9,10 +8,14 @@ import * as validator from 'validator'
 import { VideoPrivacy } from '../../shared/models/videos'
 import { readFile } from 'fs-extra'
 import { getActivityStreamDuration } from '../models/video/video-format-utils'
+import { AccountModel } from '../models/account/account'
+import { VideoChannelModel } from '../models/video/video-channel'
+import * as Bluebird from 'bluebird'
+import { CONFIG } from '../initializers/config'
 
 export class ClientHtml {
 
-  private static htmlCache: { [path: string]: string } = {}
+  private static htmlCache: { [ path: string ]: string } = {}
 
   static invalidCache () {
     ClientHtml.htmlCache = {}
@@ -28,18 +31,14 @@ export class ClientHtml {
   }
 
   static async getWatchHTMLPage (videoId: string, req: express.Request, res: express.Response) {
-    let videoPromise: Bluebird<VideoModel>
-
     // Let Angular application handle errors
-    if (validator.isInt(videoId) || validator.isUUID(videoId, 4)) {
-      videoPromise = VideoModel.loadAndPopulateAccountAndServerAndTags(videoId)
-    } else {
+    if (!validator.isInt(videoId) && !validator.isUUID(videoId, 4)) {
       return ClientHtml.getIndexHTML(req, res)
     }
 
     const [ html, video ] = await Promise.all([
       ClientHtml.getIndexHTML(req, res),
-      videoPromise
+      VideoModel.loadAndPopulateAccountAndServerAndTags(videoId)
     ])
 
     // Let Angular application handle errors
@@ -49,14 +48,44 @@ export class ClientHtml {
 
     let customHtml = ClientHtml.addTitleTag(html, escapeHTML(video.name))
     customHtml = ClientHtml.addDescriptionTag(customHtml, escapeHTML(video.description))
-    customHtml = ClientHtml.addOpenGraphAndOEmbedTags(customHtml, video)
+    customHtml = ClientHtml.addVideoOpenGraphAndOEmbedTags(customHtml, video)
+
+    return customHtml
+  }
+
+  static async getAccountHTMLPage (nameWithHost: string, req: express.Request, res: express.Response) {
+    return this.getAccountOrChannelHTMLPage(() => AccountModel.loadByNameWithHost(nameWithHost), req, res)
+  }
+
+  static async getVideoChannelHTMLPage (nameWithHost: string, req: express.Request, res: express.Response) {
+    return this.getAccountOrChannelHTMLPage(() => VideoChannelModel.loadByNameWithHostAndPopulateAccount(nameWithHost), req, res)
+  }
+
+  private static async getAccountOrChannelHTMLPage (
+    loader: () => Bluebird<AccountModel | VideoChannelModel>,
+    req: express.Request,
+    res: express.Response
+  ) {
+    const [ html, entity ] = await Promise.all([
+      ClientHtml.getIndexHTML(req, res),
+      loader()
+    ])
+
+    // Let Angular application handle errors
+    if (!entity) {
+      return ClientHtml.getIndexHTML(req, res)
+    }
+
+    let customHtml = ClientHtml.addTitleTag(html, escapeHTML(entity.getDisplayName()))
+    customHtml = ClientHtml.addDescriptionTag(customHtml, escapeHTML(entity.description))
+    customHtml = ClientHtml.addAccountOrChannelMetaTags(customHtml, entity)
 
     return customHtml
   }
 
   private static async getIndexHTML (req: express.Request, res: express.Response, paramLang?: string) {
     const path = ClientHtml.getIndexPath(req, res, paramLang)
-    if (ClientHtml.htmlCache[path]) return ClientHtml.htmlCache[path]
+    if (ClientHtml.htmlCache[ path ]) return ClientHtml.htmlCache[ path ]
 
     const buffer = await readFile(path)
 
@@ -64,7 +93,7 @@ export class ClientHtml {
 
     html = ClientHtml.addCustomCSS(html)
 
-    ClientHtml.htmlCache[path] = html
+    ClientHtml.htmlCache[ path ] = html
 
     return html
   }
@@ -78,7 +107,7 @@ export class ClientHtml {
 
       // Save locale in cookies
       res.cookie('clientLanguage', lang, {
-        secure: CONFIG.WEBSERVER.SCHEME === 'https',
+        secure: WEBSERVER.SCHEME === 'https',
         sameSite: true,
         maxAge: 1000 * 3600 * 24 * 90 // 3 months
       })
@@ -114,13 +143,13 @@ export class ClientHtml {
     return htmlStringPage.replace(CUSTOM_HTML_TAG_COMMENTS.CUSTOM_CSS, styleTag)
   }
 
-  private static addOpenGraphAndOEmbedTags (htmlStringPage: string, video: VideoModel) {
-    const previewUrl = CONFIG.WEBSERVER.URL + video.getPreviewStaticPath()
-    const videoUrl = CONFIG.WEBSERVER.URL + video.getWatchStaticPath()
+  private static addVideoOpenGraphAndOEmbedTags (htmlStringPage: string, video: VideoModel) {
+    const previewUrl = WEBSERVER.URL + video.getPreviewStaticPath()
+    const videoUrl = WEBSERVER.URL + video.getWatchStaticPath()
 
     const videoNameEscaped = escapeHTML(video.name)
     const videoDescriptionEscaped = escapeHTML(video.description)
-    const embedUrl = CONFIG.WEBSERVER.URL + video.getEmbedStaticPath()
+    const embedUrl = WEBSERVER.URL + video.getEmbedStaticPath()
 
     const openGraphMetaTags = {
       'og:type': 'video',
@@ -152,7 +181,7 @@ export class ClientHtml {
     const oembedLinkTags = [
       {
         type: 'application/json+oembed',
-        href: CONFIG.WEBSERVER.URL + '/services/oembed?url=' + encodeURIComponent(videoUrl),
+        href: WEBSERVER.URL + '/services/oembed?url=' + encodeURIComponent(videoUrl),
         title: videoNameEscaped
       }
     ]
@@ -174,7 +203,7 @@ export class ClientHtml {
 
     // Opengraph
     Object.keys(openGraphMetaTags).forEach(tagName => {
-      const tagValue = openGraphMetaTags[tagName]
+      const tagValue = openGraphMetaTags[ tagName ]
 
       tagsString += `<meta property="${tagName}" content="${tagValue}" />`
     })
@@ -190,6 +219,17 @@ export class ClientHtml {
     // SEO, use origin video url so Google does not index remote videos
     tagsString += `<link rel="canonical" href="${video.url}" />`
 
-    return htmlStringPage.replace(CUSTOM_HTML_TAG_COMMENTS.OPENGRAPH_AND_OEMBED, tagsString)
+    return this.addOpenGraphAndOEmbedTags(htmlStringPage, tagsString)
+  }
+
+  private static addAccountOrChannelMetaTags (htmlStringPage: string, entity: AccountModel | VideoChannelModel) {
+    // SEO, use origin account or channel URL
+    const metaTags = `<link rel="canonical" href="${entity.Actor.url}" />`
+
+    return this.addOpenGraphAndOEmbedTags(htmlStringPage, metaTags)
+  }
+
+  private static addOpenGraphAndOEmbedTags (htmlStringPage: string, metaTags: string) {
+    return htmlStringPage.replace(CUSTOM_HTML_TAG_COMMENTS.META_TAGS, metaTags)
   }
 }
diff --git a/server/lib/emailer.ts b/server/lib/emailer.ts
index 99010f473..8c06e9751 100644
--- a/server/lib/emailer.ts
+++ b/server/lib/emailer.ts
@@ -1,7 +1,7 @@
 import { createTransport, Transporter } from 'nodemailer'
 import { isTestInstance } from '../helpers/core-utils'
 import { bunyanLogger, logger } from '../helpers/logger'
-import { CONFIG } from '../initializers'
+import { CONFIG } from '../initializers/config'
 import { UserModel } from '../models/account/user'
 import { VideoModel } from '../models/video/video'
 import { JobQueue } from './job-queue'
@@ -12,6 +12,16 @@ import { VideoAbuseModel } from '../models/video/video-abuse'
 import { VideoBlacklistModel } from '../models/video/video-blacklist'
 import { VideoImportModel } from '../models/video/video-import'
 import { ActorFollowModel } from '../models/activitypub/actor-follow'
+import { WEBSERVER } from '../initializers/constants'
+
+type SendEmailOptions = {
+  to: string[]
+  subject: string
+  text: string
+
+  fromDisplayName?: string
+  replyTo?: string
+}
 
 class Emailer {
 
@@ -82,7 +92,7 @@ class Emailer {
 
   addNewVideoFromSubscriberNotification (to: string[], video: VideoModel) {
     const channelName = video.VideoChannel.getDisplayName()
-    const videoUrl = CONFIG.WEBSERVER.URL + video.getWatchStaticPath()
+    const videoUrl = WEBSERVER.URL + video.getWatchStaticPath()
 
     const text = `Hi dear user,\n\n` +
       `Your subscription ${channelName} just published a new video: ${video.name}` +
@@ -120,8 +130,26 @@ class Emailer {
     return JobQueue.Instance.createJob({ type: 'email', payload: emailPayload })
   }
 
+  addNewInstanceFollowerNotification (to: string[], actorFollow: ActorFollowModel) {
+    const awaitingApproval = actorFollow.state === 'pending' ? ' awaiting manual approval.' : ''
+
+    const text = `Hi dear admin,\n\n` +
+      `Your instance has a new follower: ${actorFollow.ActorFollower.url}${awaitingApproval}` +
+      `\n\n` +
+      `Cheers,\n` +
+      `PeerTube.`
+
+    const emailPayload: EmailPayload = {
+      to,
+      subject: 'New instance follower',
+      text
+    }
+
+    return JobQueue.Instance.createJob({ type: 'email', payload: emailPayload })
+  }
+
   myVideoPublishedNotification (to: string[], video: VideoModel) {
-    const videoUrl = CONFIG.WEBSERVER.URL + video.getWatchStaticPath()
+    const videoUrl = WEBSERVER.URL + video.getWatchStaticPath()
 
     const text = `Hi dear user,\n\n` +
       `Your video ${video.name} has been published.` +
@@ -141,7 +169,7 @@ class Emailer {
   }
 
   myVideoImportSuccessNotification (to: string[], videoImport: VideoImportModel) {
-    const videoUrl = CONFIG.WEBSERVER.URL + videoImport.Video.getWatchStaticPath()
+    const videoUrl = WEBSERVER.URL + videoImport.Video.getWatchStaticPath()
 
     const text = `Hi dear user,\n\n` +
       `Your video import ${videoImport.getTargetIdentifier()} is finished.` +
@@ -161,7 +189,7 @@ class Emailer {
   }
 
   myVideoImportErrorNotification (to: string[], videoImport: VideoImportModel) {
-    const importUrl = CONFIG.WEBSERVER.URL + '/my-account/video-imports'
+    const importUrl = WEBSERVER.URL + '/my-account/video-imports'
 
     const text = `Hi dear user,\n\n` +
       `Your video import ${videoImport.getTargetIdentifier()} encountered an error.` +
@@ -183,7 +211,7 @@ class Emailer {
   addNewCommentOnMyVideoNotification (to: string[], comment: VideoCommentModel) {
     const accountName = comment.Account.getDisplayName()
     const video = comment.Video
-    const commentUrl = CONFIG.WEBSERVER.URL + comment.getCommentStaticPath()
+    const commentUrl = WEBSERVER.URL + comment.getCommentStaticPath()
 
     const text = `Hi dear user,\n\n` +
       `A new comment has been posted by ${accountName} on your video ${video.name}` +
@@ -205,7 +233,7 @@ class Emailer {
   addNewCommentMentionNotification (to: string[], comment: VideoCommentModel) {
     const accountName = comment.Account.getDisplayName()
     const video = comment.Video
-    const commentUrl = CONFIG.WEBSERVER.URL + comment.getCommentStaticPath()
+    const commentUrl = WEBSERVER.URL + comment.getCommentStaticPath()
 
     const text = `Hi dear user,\n\n` +
       `${accountName} mentioned you on video ${video.name}` +
@@ -225,10 +253,10 @@ class Emailer {
   }
 
   addVideoAbuseModeratorsNotification (to: string[], videoAbuse: VideoAbuseModel) {
-    const videoUrl = CONFIG.WEBSERVER.URL + videoAbuse.Video.getWatchStaticPath()
+    const videoUrl = WEBSERVER.URL + videoAbuse.Video.getWatchStaticPath()
 
     const text = `Hi,\n\n` +
-      `${CONFIG.WEBSERVER.HOST} received an abuse for the following video ${videoUrl}\n\n` +
+      `${WEBSERVER.HOST} received an abuse for the following video ${videoUrl}\n\n` +
       `Cheers,\n` +
       `PeerTube.`
 
@@ -241,15 +269,38 @@ class Emailer {
     return JobQueue.Instance.createJob({ type: 'email', payload: emailPayload })
   }
 
+  addVideoAutoBlacklistModeratorsNotification (to: string[], video: VideoModel) {
+    const VIDEO_AUTO_BLACKLIST_URL = WEBSERVER.URL + '/admin/moderation/video-auto-blacklist/list'
+    const videoUrl = WEBSERVER.URL + video.getWatchStaticPath()
+
+    const text = `Hi,\n\n` +
+      `A recently added video was auto-blacklisted and requires moderator review before publishing.` +
+      `\n\n` +
+      `You can view it and take appropriate action on ${videoUrl}` +
+      `\n\n` +
+      `A full list of auto-blacklisted videos can be reviewed here: ${VIDEO_AUTO_BLACKLIST_URL}` +
+      `\n\n` +
+      `Cheers,\n` +
+      `PeerTube.`
+
+    const emailPayload: EmailPayload = {
+      to,
+      subject: '[PeerTube] An auto-blacklisted video is awaiting review',
+      text
+    }
+
+    return JobQueue.Instance.createJob({ type: 'email', payload: emailPayload })
+  }
+
   addNewUserRegistrationNotification (to: string[], user: UserModel) {
     const text = `Hi,\n\n` +
-      `User ${user.username} just registered on ${CONFIG.WEBSERVER.HOST} PeerTube instance.\n\n` +
+      `User ${user.username} just registered on ${WEBSERVER.HOST} PeerTube instance.\n\n` +
       `Cheers,\n` +
       `PeerTube.`
 
     const emailPayload: EmailPayload = {
       to,
-      subject: '[PeerTube] New user registration on ' + CONFIG.WEBSERVER.HOST,
+      subject: '[PeerTube] New user registration on ' + WEBSERVER.HOST,
       text
     }
 
@@ -258,10 +309,10 @@ class Emailer {
 
   addVideoBlacklistNotification (to: string[], videoBlacklist: VideoBlacklistModel) {
     const videoName = videoBlacklist.Video.name
-    const videoUrl = CONFIG.WEBSERVER.URL + videoBlacklist.Video.getWatchStaticPath()
+    const videoUrl = WEBSERVER.URL + videoBlacklist.Video.getWatchStaticPath()
 
     const reasonString = videoBlacklist.reason ? ` for the following reason: ${videoBlacklist.reason}` : ''
-    const blockedString = `Your video ${videoName} (${videoUrl} on ${CONFIG.WEBSERVER.HOST} has been blacklisted${reasonString}.`
+    const blockedString = `Your video ${videoName} (${videoUrl} on ${WEBSERVER.HOST} has been blacklisted${reasonString}.`
 
     const text = 'Hi,\n\n' +
       blockedString +
@@ -279,10 +330,10 @@ class Emailer {
   }
 
   addVideoUnblacklistNotification (to: string[], video: VideoModel) {
-    const videoUrl = CONFIG.WEBSERVER.URL + video.getWatchStaticPath()
+    const videoUrl = WEBSERVER.URL + video.getWatchStaticPath()
 
     const text = 'Hi,\n\n' +
-      `Your video ${video.name} (${videoUrl}) on ${CONFIG.WEBSERVER.HOST} has been unblacklisted.` +
+      `Your video ${video.name} (${videoUrl}) on ${WEBSERVER.HOST} has been unblacklisted.` +
       '\n\n' +
       'Cheers,\n' +
       `PeerTube.`
@@ -296,9 +347,9 @@ class Emailer {
     return JobQueue.Instance.createJob({ type: 'email', payload: emailPayload })
   }
 
-  addForgetPasswordEmailJob (to: string, resetPasswordUrl: string) {
+  addPasswordResetEmailJob (to: string, resetPasswordUrl: string) {
     const text = `Hi dear user,\n\n` +
-      `It seems you forgot your password on ${CONFIG.WEBSERVER.HOST}! ` +
+      `A reset password procedure for your account ${to} has been requested on ${WEBSERVER.HOST} ` +
       `Please follow this link to reset it: ${resetPasswordUrl}\n\n` +
       `If you are not the person who initiated this request, please ignore this email.\n\n` +
       `Cheers,\n` +
@@ -315,7 +366,7 @@ class Emailer {
 
   addVerifyEmailJob (to: string, verifyEmailUrl: string) {
     const text = `Welcome to PeerTube,\n\n` +
-      `To start using PeerTube on ${CONFIG.WEBSERVER.HOST} you must  verify your email! ` +
+      `To start using PeerTube on ${WEBSERVER.HOST} you must  verify your email! ` +
       `Please follow this link to verify this email belongs to you: ${verifyEmailUrl}\n\n` +
       `If you are not the person who initiated this request, please ignore this email.\n\n` +
       `Cheers,\n` +
@@ -333,7 +384,7 @@ class Emailer {
   addUserBlockJob (user: UserModel, blocked: boolean, reason?: string) {
     const reasonString = reason ? ` for the following reason: ${reason}` : ''
     const blockedWord = blocked ? 'blocked' : 'unblocked'
-    const blockedString = `Your account ${user.username} on ${CONFIG.WEBSERVER.HOST} has been ${blockedWord}${reasonString}.`
+    const blockedString = `Your account ${user.username} on ${WEBSERVER.HOST} has been ${blockedWord}${reasonString}.`
 
     const text = 'Hi,\n\n' +
       blockedString +
@@ -378,7 +429,7 @@ class Emailer {
 
     const fromDisplayName = options.fromDisplayName
       ? options.fromDisplayName
-      : CONFIG.WEBSERVER.HOST
+      : WEBSERVER.HOST
 
     return this.transporter.sendMail({
       from: `"${fromDisplayName}" <${CONFIG.SMTP.FROM_ADDRESS}>`,
@@ -402,5 +453,6 @@ class Emailer {
 // ---------------------------------------------------------------------------
 
 export {
-  Emailer
+  Emailer,
+  SendEmailOptions
 }
diff --git a/server/lib/files-cache/abstract-video-static-file-cache.ts b/server/lib/files-cache/abstract-video-static-file-cache.ts
new file mode 100644
index 000000000..1908cfb06
--- /dev/null
+++ b/server/lib/files-cache/abstract-video-static-file-cache.ts
@@ -0,0 +1,30 @@
+import { remove } from 'fs-extra'
+import { logger } from '../../helpers/logger'
+import * as memoizee from 'memoizee'
+
+type GetFilePathResult = { isOwned: boolean, path: string } | undefined
+
+export abstract class AbstractVideoStaticFileCache <T> {
+
+  getFilePath: (params: T) => Promise<GetFilePathResult>
+
+  abstract getFilePathImpl (params: T): Promise<GetFilePathResult>
+
+  // Load and save the remote file, then return the local path from filesystem
+  protected abstract loadRemoteFile (key: string): Promise<GetFilePathResult>
+
+  init (max: number, maxAge: number) {
+    this.getFilePath = memoizee(this.getFilePathImpl, {
+      maxAge,
+      max,
+      promise: true,
+      dispose: (result: GetFilePathResult) => {
+        if (result.isOwned !== true) {
+          remove(result.path)
+            .then(() => logger.debug('%s removed from %s', result.path, this.constructor.name))
+            .catch(err => logger.error('Cannot remove %s from cache %s.', result.path, this.constructor.name, { err }))
+        }
+      }
+    })
+  }
+}
diff --git a/server/lib/cache/actor-follow-score-cache.ts b/server/lib/files-cache/actor-follow-score-cache.ts
index d070bde09..5f8ee806f 100644
--- a/server/lib/cache/actor-follow-score-cache.ts
+++ b/server/lib/files-cache/actor-follow-score-cache.ts
@@ -1,4 +1,4 @@
-import { ACTOR_FOLLOW_SCORE } from '../../initializers'
+import { ACTOR_FOLLOW_SCORE } from '../../initializers/constants'
 import { logger } from '../../helpers/logger'
 
 // Cache follows scores, instead of writing them too often in database
diff --git a/server/lib/cache/index.ts b/server/lib/files-cache/index.ts
index e921d04a7..e921d04a7 100644
--- a/server/lib/cache/index.ts
+++ b/server/lib/files-cache/index.ts
diff --git a/server/lib/cache/videos-caption-cache.ts b/server/lib/files-cache/videos-caption-cache.ts
index f240affbc..440c3fde8 100644
--- a/server/lib/cache/videos-caption-cache.ts
+++ b/server/lib/files-cache/videos-caption-cache.ts
@@ -1,8 +1,11 @@
 import { join } from 'path'
-import { CACHE, CONFIG } from '../../initializers'
+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 { CONFIG } from '../../initializers/config'
+import { logger } from '../../helpers/logger'
+import { fetchRemoteVideoStaticFile } from '../activitypub'
 
 type GetPathParam = { videoId: string, language: string }
 
@@ -19,17 +22,19 @@ class VideosCaptionCache extends AbstractVideoStaticFileCache <GetPathParam> {
     return this.instance || (this.instance = new this())
   }
 
-  async getFilePath (params: GetPathParam) {
+  async getFilePathImpl (params: GetPathParam) {
     const videoCaption = await VideoCaptionModel.loadByVideoIdAndLanguage(params.videoId, params.language)
     if (!videoCaption) return undefined
 
-    if (videoCaption.isOwned()) return join(CONFIG.STORAGE.CAPTIONS_DIR, videoCaption.getCaptionName())
+    if (videoCaption.isOwned()) return { isOwned: true, path: join(CONFIG.STORAGE.CAPTIONS_DIR, videoCaption.getCaptionName()) }
 
     const key = params.videoId + VideosCaptionCache.KEY_DELIMITER + params.language
-    return this.loadFromLRU(key)
+    return this.loadRemoteFile(key)
   }
 
   protected async loadRemoteFile (key: string) {
+    logger.debug('Loading remote caption file %s.', key)
+
     const [ videoId, language ] = key.split(VideosCaptionCache.KEY_DELIMITER)
 
     const videoCaption = await VideoCaptionModel.loadByVideoIdAndLanguage(videoId, language)
@@ -41,10 +46,13 @@ class VideosCaptionCache extends AbstractVideoStaticFileCache <GetPathParam> {
     const video = await VideoModel.loadAndPopulateAccountAndServerAndTags(videoId)
     if (!video) return undefined
 
+    // FIXME: use URL
     const remoteStaticPath = videoCaption.getCaptionStaticPath()
-    const destPath = join(CACHE.VIDEO_CAPTIONS.DIRECTORY, videoCaption.getCaptionName())
+    const destPath = join(FILES_CACHE.VIDEO_CAPTIONS.DIRECTORY, videoCaption.getCaptionName())
+
+    await fetchRemoteVideoStaticFile(video, remoteStaticPath, destPath)
 
-    return this.saveRemoteVideoFileAndReturnPath(video, remoteStaticPath, destPath)
+    return { isOwned: false, path: destPath }
   }
 }
 
diff --git a/server/lib/cache/videos-preview-cache.ts b/server/lib/files-cache/videos-preview-cache.ts
index a5d6f5b62..14be7f24a 100644
--- a/server/lib/cache/videos-preview-cache.ts
+++ b/server/lib/files-cache/videos-preview-cache.ts
@@ -1,7 +1,9 @@
 import { join } from 'path'
-import { CACHE, CONFIG, STATIC_PATHS } from '../../initializers'
+import { FILES_CACHE, STATIC_PATHS } from '../../initializers/constants'
 import { VideoModel } from '../../models/video/video'
 import { AbstractVideoStaticFileCache } from './abstract-video-static-file-cache'
+import { CONFIG } from '../../initializers/config'
+import { fetchRemoteVideoStaticFile } from '../activitypub'
 
 class VideosPreviewCache extends AbstractVideoStaticFileCache <string> {
 
@@ -15,13 +17,13 @@ class VideosPreviewCache extends AbstractVideoStaticFileCache <string> {
     return this.instance || (this.instance = new this())
   }
 
-  async getFilePath (videoUUID: string) {
+  async getFilePathImpl (videoUUID: string) {
     const video = await VideoModel.loadByUUIDWithFile(videoUUID)
     if (!video) return undefined
 
-    if (video.isOwned()) return join(CONFIG.STORAGE.PREVIEWS_DIR, video.getPreviewName())
+    if (video.isOwned()) return { isOwned: true, path: join(CONFIG.STORAGE.PREVIEWS_DIR, video.getPreview().filename) }
 
-    return this.loadFromLRU(videoUUID)
+    return this.loadRemoteFile(videoUUID)
   }
 
   protected async loadRemoteFile (key: string) {
@@ -30,10 +32,13 @@ class VideosPreviewCache extends AbstractVideoStaticFileCache <string> {
 
     if (video.isOwned()) throw new Error('Cannot load remote preview of owned video.')
 
-    const remoteStaticPath = join(STATIC_PATHS.PREVIEWS, video.getPreviewName())
-    const destPath = join(CACHE.PREVIEWS.DIRECTORY, video.getPreviewName())
+    // FIXME: use URL
+    const remoteStaticPath = join(STATIC_PATHS.PREVIEWS, video.getPreview().filename)
+    const destPath = join(FILES_CACHE.PREVIEWS.DIRECTORY, video.getPreview().filename)
 
-    return this.saveRemoteVideoFileAndReturnPath(video, remoteStaticPath, destPath)
+    await fetchRemoteVideoStaticFile(video, remoteStaticPath, destPath)
+
+    return { isOwned: false, path: destPath }
   }
 }
 
diff --git a/server/lib/hls.ts b/server/lib/hls.ts
new file mode 100644
index 000000000..98da4dcd8
--- /dev/null
+++ b/server/lib/hls.ts
@@ -0,0 +1,184 @@
+import { VideoModel } from '../models/video/video'
+import { basename, dirname, join } from 'path'
+import { HLS_STREAMING_PLAYLIST_DIRECTORY, P2P_MEDIA_LOADER_PEER_VERSION } from '../initializers/constants'
+import { close, ensureDir, move, open, outputJSON, pathExists, read, readFile, remove, writeFile } from 'fs-extra'
+import { getVideoFileSize } from '../helpers/ffmpeg-utils'
+import { sha256 } from '../helpers/core-utils'
+import { VideoStreamingPlaylistModel } from '../models/video/video-streaming-playlist'
+import { logger } from '../helpers/logger'
+import { doRequest, doRequestAndSaveToFile } from '../helpers/requests'
+import { generateRandomString } from '../helpers/utils'
+import { flatten, uniq } from 'lodash'
+import { VideoFileModel } from '../models/video/video-file'
+import { CONFIG } from '../initializers/config'
+import { sequelizeTypescript } from '../initializers/database'
+
+async function updateStreamingPlaylistsInfohashesIfNeeded () {
+  const playlistsToUpdate = await VideoStreamingPlaylistModel.listByIncorrectPeerVersion()
+
+  // Use separate SQL queries, because we could have many videos to update
+  for (const playlist of playlistsToUpdate) {
+    await sequelizeTypescript.transaction(async t => {
+      const videoFiles = await VideoFileModel.listByStreamingPlaylist(playlist.id, t)
+
+      playlist.p2pMediaLoaderInfohashes = VideoStreamingPlaylistModel.buildP2PMediaLoaderInfoHashes(playlist.playlistUrl, videoFiles)
+      playlist.p2pMediaLoaderPeerVersion = P2P_MEDIA_LOADER_PEER_VERSION
+      await playlist.save({ transaction: t })
+    })
+  }
+}
+
+async function updateMasterHLSPlaylist (video: VideoModel) {
+  const directory = join(HLS_STREAMING_PLAYLIST_DIRECTORY, video.uuid)
+  const masterPlaylists: string[] = [ '#EXTM3U', '#EXT-X-VERSION:3' ]
+  const masterPlaylistPath = join(directory, VideoStreamingPlaylistModel.getMasterHlsPlaylistFilename())
+
+  for (const file of video.VideoFiles) {
+    // If we did not generated a playlist for this resolution, skip
+    const filePlaylistPath = join(directory, VideoStreamingPlaylistModel.getHlsPlaylistFilename(file.resolution))
+    if (await pathExists(filePlaylistPath) === false) continue
+
+    const videoFilePath = video.getVideoFilePath(file)
+
+    const size = await getVideoFileSize(videoFilePath)
+
+    const bandwidth = 'BANDWIDTH=' + video.getBandwidthBits(file)
+    const resolution = `RESOLUTION=${size.width}x${size.height}`
+
+    let line = `#EXT-X-STREAM-INF:${bandwidth},${resolution}`
+    if (file.fps) line += ',FRAME-RATE=' + file.fps
+
+    masterPlaylists.push(line)
+    masterPlaylists.push(VideoStreamingPlaylistModel.getHlsPlaylistFilename(file.resolution))
+  }
+
+  await writeFile(masterPlaylistPath, masterPlaylists.join('\n') + '\n')
+}
+
+async function updateSha256Segments (video: VideoModel) {
+  const json: { [filename: string]: { [range: string]: string } } = {}
+
+  const playlistDirectory = join(HLS_STREAMING_PLAYLIST_DIRECTORY, video.uuid)
+
+  // For all the resolutions available for this video
+  for (const file of video.VideoFiles) {
+    const rangeHashes: { [range: string]: string } = {}
+
+    const videoPath = join(playlistDirectory, VideoStreamingPlaylistModel.getHlsVideoName(video.uuid, file.resolution))
+    const playlistPath = join(playlistDirectory, VideoStreamingPlaylistModel.getHlsPlaylistFilename(file.resolution))
+
+    // Maybe the playlist is not generated for this resolution yet
+    if (!await pathExists(playlistPath)) continue
+
+    const playlistContent = await readFile(playlistPath)
+    const ranges = getRangesFromPlaylist(playlistContent.toString())
+
+    const fd = await open(videoPath, 'r')
+    for (const range of ranges) {
+      const buf = Buffer.alloc(range.length)
+      await read(fd, buf, 0, range.length, range.offset)
+
+      rangeHashes[`${range.offset}-${range.offset + range.length - 1}`] = sha256(buf)
+    }
+    await close(fd)
+
+    const videoFilename = VideoStreamingPlaylistModel.getHlsVideoName(video.uuid, file.resolution)
+    json[videoFilename] = rangeHashes
+  }
+
+  const outputPath = join(playlistDirectory, VideoStreamingPlaylistModel.getHlsSha256SegmentsFilename())
+  await outputJSON(outputPath, json)
+}
+
+function getRangesFromPlaylist (playlistContent: string) {
+  const ranges: { offset: number, length: number }[] = []
+  const lines = playlistContent.split('\n')
+  const regex = /^#EXT-X-BYTERANGE:(\d+)@(\d+)$/
+
+  for (const line of lines) {
+    const captured = regex.exec(line)
+
+    if (captured) {
+      ranges.push({ length: parseInt(captured[1], 10), offset: parseInt(captured[2], 10) })
+    }
+  }
+
+  return ranges
+}
+
+function downloadPlaylistSegments (playlistUrl: string, destinationDir: string, timeout: number) {
+  let timer
+
+  logger.info('Importing HLS playlist %s', playlistUrl)
+
+  return new Promise<string>(async (res, rej) => {
+    const tmpDirectory = join(CONFIG.STORAGE.TMP_DIR, await generateRandomString(10))
+
+    await ensureDir(tmpDirectory)
+
+    timer = setTimeout(() => {
+      deleteTmpDirectory(tmpDirectory)
+
+      return rej(new Error('HLS download timeout.'))
+    }, timeout)
+
+    try {
+      // Fetch master playlist
+      const subPlaylistUrls = await fetchUniqUrls(playlistUrl)
+
+      const subRequests = subPlaylistUrls.map(u => fetchUniqUrls(u))
+      const fileUrls = uniq(flatten(await Promise.all(subRequests)))
+
+      logger.debug('Will download %d HLS files.', fileUrls.length, { fileUrls })
+
+      for (const fileUrl of fileUrls) {
+        const destPath = join(tmpDirectory, basename(fileUrl))
+
+        const bodyKBLimit = 10 * 1000 * 1000 // 10GB
+        await doRequestAndSaveToFile({ uri: fileUrl }, destPath, bodyKBLimit)
+      }
+
+      clearTimeout(timer)
+
+      await move(tmpDirectory, destinationDir, { overwrite: true })
+
+      return res()
+    } catch (err) {
+      deleteTmpDirectory(tmpDirectory)
+
+      return rej(err)
+    }
+  })
+
+  function deleteTmpDirectory (directory: string) {
+    remove(directory)
+      .catch(err => logger.error('Cannot delete path on HLS download error.', { err }))
+  }
+
+  async function fetchUniqUrls (playlistUrl: string) {
+    const { body } = await doRequest<string>({ uri: playlistUrl })
+
+    if (!body) return []
+
+    const urls = body.split('\n')
+      .filter(line => line.endsWith('.m3u8') || line.endsWith('.mp4'))
+      .map(url => {
+        if (url.startsWith('http://') || url.startsWith('https://')) return url
+
+        return `${dirname(playlistUrl)}/${url}`
+      })
+
+    return uniq(urls)
+  }
+}
+
+// ---------------------------------------------------------------------------
+
+export {
+  updateMasterHLSPlaylist,
+  updateSha256Segments,
+  downloadPlaylistSegments,
+  updateStreamingPlaylistsInfohashesIfNeeded
+}
+
+// ---------------------------------------------------------------------------
diff --git a/server/lib/job-queue/handlers/activitypub-follow.ts b/server/lib/job-queue/handlers/activitypub-follow.ts
index b4d381062..b3defb617 100644
--- a/server/lib/job-queue/handlers/activitypub-follow.ts
+++ b/server/lib/job-queue/handlers/activitypub-follow.ts
@@ -1,6 +1,6 @@
 import * as Bull from 'bull'
 import { logger } from '../../../helpers/logger'
-import { CONFIG, REMOTE_SCHEME, sequelizeTypescript } from '../../../initializers'
+import { REMOTE_SCHEME, WEBSERVER } from '../../../initializers/constants'
 import { sendFollow } from '../../activitypub/send'
 import { sanitizeHost } from '../../../helpers/core-utils'
 import { loadActorUrlOrGetFromWebfinger } from '../../../helpers/webfinger'
@@ -9,6 +9,7 @@ import { retryTransactionWrapper } from '../../../helpers/database-utils'
 import { ActorFollowModel } from '../../../models/activitypub/actor-follow'
 import { ActorModel } from '../../../models/activitypub/actor'
 import { Notifier } from '../../notifier'
+import { sequelizeTypescript } from '../../../initializers/database'
 
 export type ActivitypubFollowPayload = {
   followerActorId: number
@@ -23,7 +24,7 @@ async function processActivityPubFollow (job: Bull.Job) {
   logger.info('Processing ActivityPub follow in job %d.', job.id)
 
   let targetActor: ActorModel
-  if (!host || host === CONFIG.WEBSERVER.HOST) {
+  if (!host || host === WEBSERVER.HOST) {
     targetActor = await ActorModel.loadLocalByName(payload.name)
   } else {
     const sanitizedHost = sanitizeHost(host, REMOTE_SCHEME.HTTP)
@@ -73,5 +74,5 @@ async function follow (fromActor: ActorModel, targetActor: ActorModel) {
     return actorFollow
   })
 
-  if (actorFollow.state === 'accepted') Notifier.Instance.notifyOfNewFollow(actorFollow)
+  if (actorFollow.state === 'accepted') Notifier.Instance.notifyOfNewUserFollow(actorFollow)
 }
diff --git a/server/lib/job-queue/handlers/activitypub-http-broadcast.ts b/server/lib/job-queue/handlers/activitypub-http-broadcast.ts
index 9493945ff..0ff7b44a0 100644
--- a/server/lib/job-queue/handlers/activitypub-http-broadcast.ts
+++ b/server/lib/job-queue/handlers/activitypub-http-broadcast.ts
@@ -2,10 +2,9 @@ import * as Bull from 'bull'
 import * as Bluebird from 'bluebird'
 import { logger } from '../../../helpers/logger'
 import { doRequest } from '../../../helpers/requests'
-import { ActorFollowModel } from '../../../models/activitypub/actor-follow'
 import { buildGlobalHeaders, buildSignedRequestOptions, computeBody } from './utils/activitypub-http-utils'
-import { BROADCAST_CONCURRENCY, JOB_REQUEST_TIMEOUT } from '../../../initializers'
-import { ActorFollowScoreCache } from '../../cache'
+import { BROADCAST_CONCURRENCY, JOB_REQUEST_TIMEOUT } from '../../../initializers/constants'
+import { ActorFollowScoreCache } from '../../files-cache'
 
 export type ActivitypubHttpBroadcastPayload = {
   uris: string[]
diff --git a/server/lib/job-queue/handlers/activitypub-http-fetcher.ts b/server/lib/job-queue/handlers/activitypub-http-fetcher.ts
index 67ccfa995..23d33c26f 100644
--- a/server/lib/job-queue/handlers/activitypub-http-fetcher.ts
+++ b/server/lib/job-queue/handlers/activitypub-http-fetcher.ts
@@ -1,17 +1,24 @@
 import * as Bull from 'bull'
+import * as Bluebird from 'bluebird'
 import { logger } from '../../../helpers/logger'
 import { processActivities } from '../../activitypub/process'
 import { addVideoComments } from '../../activitypub/video-comments'
 import { crawlCollectionPage } from '../../activitypub/crawl'
 import { VideoModel } from '../../../models/video/video'
 import { addVideoShares, createRates } from '../../activitypub'
+import { createAccountPlaylists } from '../../activitypub/playlist'
+import { AccountModel } from '../../../models/account/account'
+import { AccountVideoRateModel } from '../../../models/account/account-video-rate'
+import { VideoShareModel } from '../../../models/video/video-share'
+import { VideoCommentModel } from '../../../models/video/video-comment'
 
-type FetchType = 'activity' | 'video-likes' | 'video-dislikes' | 'video-shares' | 'video-comments'
+type FetchType = 'activity' | 'video-likes' | 'video-dislikes' | 'video-shares' | 'video-comments' | 'account-playlists'
 
 export type ActivitypubHttpFetcherPayload = {
   uri: string
   type: FetchType
   videoId?: number
+  accountId?: number
 }
 
 async function processActivityPubHttpFetcher (job: Bull.Job) {
@@ -22,15 +29,26 @@ async function processActivityPubHttpFetcher (job: Bull.Job) {
   let video: VideoModel
   if (payload.videoId) video = await VideoModel.loadAndPopulateAccountAndServerAndTags(payload.videoId)
 
+  let account: AccountModel
+  if (payload.accountId) account = await AccountModel.load(payload.accountId)
+
   const fetcherType: { [ id in FetchType ]: (items: any[]) => Promise<any> } = {
     'activity': items => processActivities(items, { outboxUrl: payload.uri }),
     'video-likes': items => createRates(items, video, 'like'),
     'video-dislikes': items => createRates(items, video, 'dislike'),
     'video-shares': items => addVideoShares(items, video),
-    'video-comments': items => addVideoComments(items, video)
+    'video-comments': items => addVideoComments(items, video),
+    'account-playlists': items => createAccountPlaylists(items, account)
+  }
+
+  const cleanerType: { [ id in FetchType ]?: (crawlStartDate: Date) => Bluebird<any> } = {
+    'video-likes': crawlStartDate => AccountVideoRateModel.cleanOldRatesOf(video.id, 'like' as 'like', crawlStartDate),
+    'video-dislikes': crawlStartDate => AccountVideoRateModel.cleanOldRatesOf(video.id, 'dislike' as 'dislike', crawlStartDate),
+    'video-shares': crawlStartDate => VideoShareModel.cleanOldSharesOf(video.id, crawlStartDate),
+    'video-comments': crawlStartDate => VideoCommentModel.cleanOldCommentsOf(video.id, crawlStartDate)
   }
 
-  return crawlCollectionPage(payload.uri, fetcherType[payload.type])
+  return crawlCollectionPage(payload.uri, fetcherType[payload.type], cleanerType[payload.type])
 }
 
 // ---------------------------------------------------------------------------
diff --git a/server/lib/job-queue/handlers/activitypub-http-unicast.ts b/server/lib/job-queue/handlers/activitypub-http-unicast.ts
index 3973dcdc8..c70ce3be9 100644
--- a/server/lib/job-queue/handlers/activitypub-http-unicast.ts
+++ b/server/lib/job-queue/handlers/activitypub-http-unicast.ts
@@ -2,8 +2,8 @@ import * as Bull from 'bull'
 import { logger } from '../../../helpers/logger'
 import { doRequest } from '../../../helpers/requests'
 import { buildGlobalHeaders, buildSignedRequestOptions, computeBody } from './utils/activitypub-http-utils'
-import { JOB_REQUEST_TIMEOUT } from '../../../initializers'
-import { ActorFollowScoreCache } from '../../cache'
+import { JOB_REQUEST_TIMEOUT } from '../../../initializers/constants'
+import { ActorFollowScoreCache } from '../../files-cache'
 
 export type ActivitypubHttpUnicastPayload = {
   uri: string
diff --git a/server/lib/job-queue/handlers/activitypub-refresher.ts b/server/lib/job-queue/handlers/activitypub-refresher.ts
index 454b975fe..4d6c38cfa 100644
--- a/server/lib/job-queue/handlers/activitypub-refresher.ts
+++ b/server/lib/job-queue/handlers/activitypub-refresher.ts
@@ -1,11 +1,12 @@
 import * as Bull from 'bull'
 import { logger } from '../../../helpers/logger'
 import { fetchVideoByUrl } from '../../../helpers/video'
-import { refreshVideoIfNeeded, refreshActorIfNeeded } from '../../activitypub'
+import { refreshActorIfNeeded, refreshVideoIfNeeded, refreshVideoPlaylistIfNeeded } from '../../activitypub'
 import { ActorModel } from '../../../models/activitypub/actor'
+import { VideoPlaylistModel } from '../../../models/video/video-playlist'
 
 export type RefreshPayload = {
-  type: 'video' | 'actor'
+  type: 'video' | 'video-playlist' | 'actor'
   url: string
 }
 
@@ -15,13 +16,13 @@ async function refreshAPObject (job: Bull.Job) {
   logger.info('Processing AP refresher in job %d for %s.', job.id, payload.url)
 
   if (payload.type === 'video') return refreshVideo(payload.url)
+  if (payload.type === 'video-playlist') return refreshVideoPlaylist(payload.url)
   if (payload.type === 'actor') return refreshActor(payload.url)
 }
 
 // ---------------------------------------------------------------------------
 
 export {
-  refreshActor,
   refreshAPObject
 }
 
@@ -50,5 +51,12 @@ async function refreshActor (actorUrl: string) {
   if (actor) {
     await refreshActorIfNeeded(actor, fetchType)
   }
+}
+
+async function refreshVideoPlaylist (playlistUrl: string) {
+  const playlist = await VideoPlaylistModel.loadByUrlAndPopulateAccount(playlistUrl)
 
+  if (playlist) {
+    await refreshVideoPlaylistIfNeeded(playlist)
+  }
 }
diff --git a/server/lib/job-queue/handlers/email.ts b/server/lib/job-queue/handlers/email.ts
index 2ba39a156..62701222c 100644
--- a/server/lib/job-queue/handlers/email.ts
+++ b/server/lib/job-queue/handlers/email.ts
@@ -1,15 +1,8 @@
 import * as Bull from 'bull'
 import { logger } from '../../../helpers/logger'
-import { Emailer } from '../../emailer'
+import { Emailer, SendEmailOptions } from '../../emailer'
 
-export type EmailPayload = {
-  to: string[]
-  subject: string
-  text: string
-
-  fromDisplayName?: string
-  replyTo?: string
-}
+export type EmailPayload = SendEmailOptions
 
 async function processEmail (job: Bull.Job) {
   const payload = job.data as EmailPayload
diff --git a/server/lib/job-queue/handlers/utils/activitypub-http-utils.ts b/server/lib/job-queue/handlers/utils/activitypub-http-utils.ts
index 4961d4502..cdee1f6fd 100644
--- a/server/lib/job-queue/handlers/utils/activitypub-http-utils.ts
+++ b/server/lib/job-queue/handlers/utils/activitypub-http-utils.ts
@@ -2,7 +2,7 @@ import { buildSignedActivity } from '../../../../helpers/activitypub'
 import { getServerActor } from '../../../../helpers/utils'
 import { ActorModel } from '../../../../models/activitypub/actor'
 import { sha256 } from '../../../../helpers/core-utils'
-import { HTTP_SIGNATURE } from '../../../../initializers'
+import { HTTP_SIGNATURE } from '../../../../initializers/constants'
 
 type Payload = { body: any, signatureActorId?: number }
 
@@ -28,7 +28,7 @@ async function buildSignedRequestOptions (payload: Payload) {
     actor = await getServerActor()
   }
 
-  const keyId = actor.getWebfingerUrl()
+  const keyId = actor.url
   return {
     algorithm: HTTP_SIGNATURE.ALGORITHM,
     authorizationHeaderName: HTTP_SIGNATURE.HEADER_NAME,
diff --git a/server/lib/job-queue/handlers/video-file-import.ts b/server/lib/job-queue/handlers/video-file-import.ts
new file mode 100644
index 000000000..921d9a083
--- /dev/null
+++ b/server/lib/job-queue/handlers/video-file-import.ts
@@ -0,0 +1,78 @@
+import * as Bull from 'bull'
+import { logger } from '../../../helpers/logger'
+import { VideoModel } from '../../../models/video/video'
+import { publishVideoIfNeeded } from './video-transcoding'
+import { getVideoFileFPS, getVideoFileResolution } from '../../../helpers/ffmpeg-utils'
+import { copy, stat } from 'fs-extra'
+import { VideoFileModel } from '../../../models/video/video-file'
+import { extname } from 'path'
+
+export type VideoFileImportPayload = {
+  videoUUID: string,
+  filePath: string
+}
+
+async function processVideoFileImport (job: Bull.Job) {
+  const payload = job.data as VideoFileImportPayload
+  logger.info('Processing video file import in job %d.', job.id)
+
+  const video = await VideoModel.loadAndPopulateAccountAndServerAndTags(payload.videoUUID)
+  // No video, maybe deleted?
+  if (!video) {
+    logger.info('Do not process job %d, video does not exist.', job.id)
+    return undefined
+  }
+
+  await updateVideoFile(video, payload.filePath)
+
+  await publishVideoIfNeeded(video)
+  return video
+}
+
+// ---------------------------------------------------------------------------
+
+export {
+  processVideoFileImport
+}
+
+// ---------------------------------------------------------------------------
+
+async function updateVideoFile (video: VideoModel, inputFilePath: string) {
+  const { videoFileResolution } = await getVideoFileResolution(inputFilePath)
+  const { size } = await stat(inputFilePath)
+  const fps = await getVideoFileFPS(inputFilePath)
+
+  let updatedVideoFile = new VideoFileModel({
+    resolution: videoFileResolution,
+    extname: extname(inputFilePath),
+    size,
+    fps,
+    videoId: video.id
+  })
+
+  const currentVideoFile = video.VideoFiles.find(videoFile => videoFile.resolution === updatedVideoFile.resolution)
+
+  if (currentVideoFile) {
+    // Remove old file and old torrent
+    await video.removeFile(currentVideoFile)
+    await video.removeTorrent(currentVideoFile)
+    // Remove the old video file from the array
+    video.VideoFiles = video.VideoFiles.filter(f => f !== currentVideoFile)
+
+    // Update the database
+    currentVideoFile.set('extname', updatedVideoFile.extname)
+    currentVideoFile.set('size', updatedVideoFile.size)
+    currentVideoFile.set('fps', updatedVideoFile.fps)
+
+    updatedVideoFile = currentVideoFile
+  }
+
+  const outputPath = video.getVideoFilePath(updatedVideoFile)
+  await copy(inputFilePath, outputPath)
+
+  await video.createTorrentAndSetInfoHash(updatedVideoFile)
+
+  await updatedVideoFile.save()
+
+  video.VideoFiles.push(updatedVideoFile)
+}
diff --git a/server/lib/job-queue/handlers/video-import.ts b/server/lib/job-queue/handlers/video-import.ts
index 12004dcd7..1650916a6 100644
--- a/server/lib/job-queue/handlers/video-import.ts
+++ b/server/lib/job-queue/handlers/video-import.ts
@@ -6,16 +6,20 @@ import { VideoImportState } from '../../../../shared/models/videos'
 import { getDurationFromVideoFile, getVideoFileFPS, getVideoFileResolution } from '../../../helpers/ffmpeg-utils'
 import { extname, join } from 'path'
 import { VideoFileModel } from '../../../models/video/video-file'
-import { CONFIG, PREVIEWS_SIZE, sequelizeTypescript, THUMBNAILS_SIZE, VIDEO_IMPORT_TIMEOUT } from '../../../initializers'
-import { downloadImage } from '../../../helpers/requests'
+import { VIDEO_IMPORT_TIMEOUT } from '../../../initializers/constants'
 import { VideoState } from '../../../../shared'
 import { JobQueue } from '../index'
 import { federateVideoIfNeeded } from '../../activitypub'
 import { VideoModel } from '../../../models/video/video'
 import { downloadWebTorrentVideo } from '../../../helpers/webtorrent'
 import { getSecureTorrentName } from '../../../helpers/utils'
-import { remove, move, stat } from 'fs-extra'
+import { move, remove, stat } from 'fs-extra'
 import { Notifier } from '../../notifier'
+import { CONFIG } from '../../../initializers/config'
+import { sequelizeTypescript } from '../../../initializers/database'
+import { ThumbnailModel } from '../../../models/video/thumbnail'
+import { createVideoMiniatureFromUrl, generateVideoMiniature } from '../../thumbnail'
+import { ThumbnailType } from '../../../../shared/models/videos/thumbnail.type'
 
 type VideoImportYoutubeDLPayload = {
   type: 'youtube-dl'
@@ -144,25 +148,19 @@ async function processFile (downloader: () => Promise<string>, videoImport: Vide
     tempVideoPath = null // This path is not used anymore
 
     // Process thumbnail
-    if (options.downloadThumbnail) {
-      if (options.thumbnailUrl) {
-        await downloadImage(options.thumbnailUrl, CONFIG.STORAGE.THUMBNAILS_DIR, videoImport.Video.getThumbnailName(), THUMBNAILS_SIZE)
-      } else {
-        await videoImport.Video.createThumbnail(videoFile)
-      }
-    } else if (options.generateThumbnail) {
-      await videoImport.Video.createThumbnail(videoFile)
+    let thumbnailModel: ThumbnailModel
+    if (options.downloadThumbnail && options.thumbnailUrl) {
+      thumbnailModel = await createVideoMiniatureFromUrl(options.thumbnailUrl, videoImport.Video, ThumbnailType.MINIATURE)
+    } else if (options.generateThumbnail || options.downloadThumbnail) {
+      thumbnailModel = await generateVideoMiniature(videoImport.Video, videoFile, ThumbnailType.MINIATURE)
     }
 
     // Process preview
-    if (options.downloadPreview) {
-      if (options.thumbnailUrl) {
-        await downloadImage(options.thumbnailUrl, CONFIG.STORAGE.PREVIEWS_DIR, videoImport.Video.getPreviewName(), PREVIEWS_SIZE)
-      } else {
-        await videoImport.Video.createPreview(videoFile)
-      }
-    } else if (options.generatePreview) {
-      await videoImport.Video.createPreview(videoFile)
+    let previewModel: ThumbnailModel
+    if (options.downloadPreview && options.thumbnailUrl) {
+      previewModel = await createVideoMiniatureFromUrl(options.thumbnailUrl, videoImport.Video, ThumbnailType.PREVIEW)
+    } else if (options.generatePreview || options.downloadPreview) {
+      previewModel = await generateVideoMiniature(videoImport.Video, videoFile, ThumbnailType.PREVIEW)
     }
 
     // Create torrent
@@ -182,6 +180,9 @@ async function processFile (downloader: () => Promise<string>, videoImport: Vide
       video.state = CONFIG.TRANSCODING.ENABLED ? VideoState.TO_TRANSCODE : VideoState.PUBLISHED
       await video.save({ transaction: t })
 
+      if (thumbnailModel) await video.addAndSaveThumbnail(thumbnailModel, t)
+      if (previewModel) await video.addAndSaveThumbnail(previewModel, t)
+
       // Now we can federate the video (reload from database, we need more attributes)
       const videoForFederation = await VideoModel.loadAndPopulateAccountAndServerAndTags(video.uuid, t)
       await federateVideoIfNeeded(videoForFederation, true, t)
@@ -196,9 +197,14 @@ async function processFile (downloader: () => Promise<string>, videoImport: Vide
       return videoImportUpdated
     })
 
-    Notifier.Instance.notifyOnNewVideo(videoImportUpdated.Video)
     Notifier.Instance.notifyOnFinishedVideoImport(videoImportUpdated, true)
 
+    if (videoImportUpdated.Video.VideoBlacklist) {
+      Notifier.Instance.notifyOnVideoAutoBlacklist(videoImportUpdated.Video)
+    } else {
+      Notifier.Instance.notifyOnNewVideo(videoImportUpdated.Video)
+    }
+
     // Create transcoding jobs?
     if (videoImportUpdated.Video.state === VideoState.TO_TRANSCODE) {
       // Put uuid because we don't have id auto incremented for now
@@ -207,7 +213,7 @@ async function processFile (downloader: () => Promise<string>, videoImport: Vide
         isNewVideo: true
       }
 
-      await JobQueue.Instance.createJob({ type: 'video-file', payload: dataInput })
+      await JobQueue.Instance.createJob({ type: 'video-transcoding', payload: dataInput })
     }
 
   } catch (err) {
diff --git a/server/lib/job-queue/handlers/video-file.ts b/server/lib/job-queue/handlers/video-transcoding.ts
index 593e43cc5..48cac517e 100644
--- a/server/lib/job-queue/handlers/video-file.ts
+++ b/server/lib/job-queue/handlers/video-transcoding.ts
@@ -8,40 +8,20 @@ import { retryTransactionWrapper } from '../../../helpers/database-utils'
 import { sequelizeTypescript } from '../../../initializers'
 import * as Bluebird from 'bluebird'
 import { computeResolutionsToTranscode } from '../../../helpers/ffmpeg-utils'
-import { importVideoFile, optimizeVideofile, transcodeOriginalVideofile } from '../../video-transcoding'
+import { generateHlsPlaylist, optimizeVideofile, transcodeOriginalVideofile } from '../../video-transcoding'
 import { Notifier } from '../../notifier'
+import { CONFIG } from '../../../initializers/config'
 
-export type VideoFilePayload = {
+export type VideoTranscodingPayload = {
   videoUUID: string
-  isNewVideo?: boolean
   resolution?: VideoResolution
+  isNewVideo?: boolean
   isPortraitMode?: boolean
+  generateHlsPlaylist?: boolean
 }
 
-export type VideoFileImportPayload = {
-  videoUUID: string,
-  filePath: string
-}
-
-async function processVideoFileImport (job: Bull.Job) {
-  const payload = job.data as VideoFileImportPayload
-  logger.info('Processing video file import in job %d.', job.id)
-
-  const video = await VideoModel.loadAndPopulateAccountAndServerAndTags(payload.videoUUID)
-  // No video, maybe deleted?
-  if (!video) {
-    logger.info('Do not process job %d, video does not exist.', job.id)
-    return undefined
-  }
-
-  await importVideoFile(video, payload.filePath)
-
-  await onVideoFileTranscoderOrImportSuccess(video)
-  return video
-}
-
-async function processVideoFile (job: Bull.Job) {
-  const payload = job.data as VideoFilePayload
+async function processVideoTranscoding (job: Bull.Job) {
+  const payload = job.data as VideoTranscodingPayload
   logger.info('Processing video file in job %d.', job.id)
 
   const video = await VideoModel.loadAndPopulateAccountAndServerAndTags(payload.videoUUID)
@@ -51,23 +31,38 @@ async function processVideoFile (job: Bull.Job) {
     return undefined
   }
 
-  // Transcoding in other resolution
-  if (payload.resolution) {
+  if (payload.generateHlsPlaylist) {
+    await generateHlsPlaylist(video, payload.resolution, payload.isPortraitMode || false)
+
+    await retryTransactionWrapper(onHlsPlaylistGenerationSuccess, video)
+  } else if (payload.resolution) { // Transcoding in other resolution
     await transcodeOriginalVideofile(video, payload.resolution, payload.isPortraitMode || false)
 
-    await retryTransactionWrapper(onVideoFileTranscoderOrImportSuccess, video)
+    await retryTransactionWrapper(publishVideoIfNeeded, video, payload)
   } else {
     await optimizeVideofile(video)
 
-    await retryTransactionWrapper(onVideoFileOptimizerSuccess, video, payload.isNewVideo)
+    await retryTransactionWrapper(onVideoFileOptimizerSuccess, video, payload)
   }
 
   return video
 }
 
-async function onVideoFileTranscoderOrImportSuccess (video: VideoModel) {
+async function onHlsPlaylistGenerationSuccess (video: VideoModel) {
   if (video === undefined) return undefined
 
+  await sequelizeTypescript.transaction(async t => {
+    // Maybe the video changed in database, refresh it
+    let videoDatabase = await VideoModel.loadAndPopulateAccountAndServerAndTags(video.uuid, t)
+    // Video does not exist anymore
+    if (!videoDatabase) return undefined
+
+    // If the video was not published, we consider it is a new one for other instances
+    await federateVideoIfNeeded(videoDatabase, false, t)
+  })
+}
+
+async function publishVideoIfNeeded (video: VideoModel, payload?: VideoTranscodingPayload) {
   const { videoDatabase, videoPublished } = await sequelizeTypescript.transaction(async t => {
     // Maybe the video changed in database, refresh it
     let videoDatabase = await VideoModel.loadAndPopulateAccountAndServerAndTags(video.uuid, t)
@@ -93,11 +88,13 @@ async function onVideoFileTranscoderOrImportSuccess (video: VideoModel) {
 
   if (videoPublished) {
     Notifier.Instance.notifyOnNewVideo(videoDatabase)
-    Notifier.Instance.notifyOnPendingVideoPublished(videoDatabase)
+    Notifier.Instance.notifyOnVideoPublishedAfterTranscoding(videoDatabase)
   }
+
+  await createHlsJobIfEnabled(payload)
 }
 
-async function onVideoFileOptimizerSuccess (videoArg: VideoModel, isNewVideo: boolean) {
+async function onVideoFileOptimizerSuccess (videoArg: VideoModel, payload: VideoTranscodingPayload) {
   if (videoArg === undefined) return undefined
 
   // Outside the transaction (IO on disk)
@@ -119,7 +116,7 @@ async function onVideoFileOptimizerSuccess (videoArg: VideoModel, isNewVideo: bo
     let videoPublished = false
 
     if (resolutionsEnabled.length !== 0) {
-      const tasks: Bluebird<Bull.Job<any>>[] = []
+      const tasks: (Bluebird<Bull.Job<any>> | Promise<Bull.Job<any>>)[] = []
 
       for (const resolution of resolutionsEnabled) {
         const dataInput = {
@@ -127,7 +124,7 @@ async function onVideoFileOptimizerSuccess (videoArg: VideoModel, isNewVideo: bo
           resolution
         }
 
-        const p = JobQueue.Instance.createJob({ type: 'video-file', payload: dataInput })
+        const p = JobQueue.Instance.createJob({ type: 'video-transcoding', payload: dataInput })
         tasks.push(p)
       }
 
@@ -144,18 +141,37 @@ async function onVideoFileOptimizerSuccess (videoArg: VideoModel, isNewVideo: bo
       logger.info('No transcoding jobs created for video %s (no resolutions).', videoDatabase.uuid, { privacy: videoDatabase.privacy })
     }
 
-    await federateVideoIfNeeded(videoDatabase, isNewVideo, t)
+    await federateVideoIfNeeded(videoDatabase, payload.isNewVideo, t)
 
     return { videoDatabase, videoPublished }
   })
 
-  if (isNewVideo) Notifier.Instance.notifyOnNewVideo(videoDatabase)
-  if (videoPublished) Notifier.Instance.notifyOnPendingVideoPublished(videoDatabase)
+  if (payload.isNewVideo) Notifier.Instance.notifyOnNewVideo(videoDatabase)
+  if (videoPublished) Notifier.Instance.notifyOnVideoPublishedAfterTranscoding(videoDatabase)
+
+  await createHlsJobIfEnabled(Object.assign({}, payload, { resolution: videoDatabase.getOriginalFile().resolution }))
 }
 
 // ---------------------------------------------------------------------------
 
 export {
-  processVideoFile,
-  processVideoFileImport
+  processVideoTranscoding,
+  publishVideoIfNeeded
+}
+
+// ---------------------------------------------------------------------------
+
+function createHlsJobIfEnabled (payload?: VideoTranscodingPayload) {
+  // Generate HLS playlist?
+  if (payload && CONFIG.TRANSCODING.HLS.ENABLED) {
+    const hlsTranscodingPayload = {
+      videoUUID: payload.videoUUID,
+      resolution: payload.resolution,
+      isPortraitMode: payload.isPortraitMode,
+
+      generateHlsPlaylist: true
+    }
+
+    return JobQueue.Instance.createJob({ type: 'video-transcoding', payload: hlsTranscodingPayload })
+  }
 }
diff --git a/server/lib/job-queue/job-queue.ts b/server/lib/job-queue/job-queue.ts
index ba9cbe0d9..3c810da98 100644
--- a/server/lib/job-queue/job-queue.ts
+++ b/server/lib/job-queue/job-queue.ts
@@ -2,16 +2,17 @@ import * as Bull from 'bull'
 import { JobState, JobType } from '../../../shared/models'
 import { logger } from '../../helpers/logger'
 import { Redis } from '../redis'
-import { CONFIG, JOB_ATTEMPTS, JOB_COMPLETED_LIFETIME, JOB_CONCURRENCY, JOB_TTL, REPEAT_JOBS } from '../../initializers'
+import { JOB_ATTEMPTS, JOB_COMPLETED_LIFETIME, JOB_CONCURRENCY, JOB_TTL, REPEAT_JOBS, WEBSERVER } from '../../initializers/constants'
 import { ActivitypubHttpBroadcastPayload, processActivityPubHttpBroadcast } from './handlers/activitypub-http-broadcast'
 import { ActivitypubHttpFetcherPayload, processActivityPubHttpFetcher } from './handlers/activitypub-http-fetcher'
 import { ActivitypubHttpUnicastPayload, processActivityPubHttpUnicast } from './handlers/activitypub-http-unicast'
 import { EmailPayload, processEmail } from './handlers/email'
-import { processVideoFile, processVideoFileImport, VideoFileImportPayload, VideoFilePayload } from './handlers/video-file'
+import { processVideoTranscoding, VideoTranscodingPayload } from './handlers/video-transcoding'
 import { ActivitypubFollowPayload, processActivityPubFollow } from './handlers/activitypub-follow'
 import { processVideoImport, VideoImportPayload } from './handlers/video-import'
 import { processVideosViews } from './handlers/video-views'
 import { refreshAPObject, RefreshPayload } from './handlers/activitypub-refresher'
+import { processVideoFileImport, VideoFileImportPayload } from './handlers/video-file-import'
 
 type CreateJobArgument =
   { type: 'activitypub-http-broadcast', payload: ActivitypubHttpBroadcastPayload } |
@@ -19,19 +20,20 @@ type CreateJobArgument =
   { type: 'activitypub-http-fetcher', payload: ActivitypubHttpFetcherPayload } |
   { type: 'activitypub-follow', payload: ActivitypubFollowPayload } |
   { type: 'video-file-import', payload: VideoFileImportPayload } |
-  { type: 'video-file', payload: VideoFilePayload } |
+  { type: 'video-transcoding', payload: VideoTranscodingPayload } |
   { type: 'email', payload: EmailPayload } |
   { type: 'video-import', payload: VideoImportPayload } |
   { type: 'activitypub-refresher', payload: RefreshPayload } |
   { type: 'videos-views', payload: {} }
 
-const handlers: { [ id in JobType ]: (job: Bull.Job) => Promise<any>} = {
+const handlers: { [ id in (JobType | 'video-file') ]: (job: Bull.Job) => Promise<any>} = {
   'activitypub-http-broadcast': processActivityPubHttpBroadcast,
   'activitypub-http-unicast': processActivityPubHttpUnicast,
   'activitypub-http-fetcher': processActivityPubHttpFetcher,
   'activitypub-follow': processActivityPubFollow,
   'video-file-import': processVideoFileImport,
-  'video-file': processVideoFile,
+  'video-transcoding': processVideoTranscoding,
+  'video-file': processVideoTranscoding, // TODO: remove it (changed in 1.3)
   'email': processEmail,
   'video-import': processVideoImport,
   'videos-views': processVideosViews,
@@ -44,7 +46,7 @@ const jobTypes: JobType[] = [
   'activitypub-http-fetcher',
   'activitypub-http-unicast',
   'email',
-  'video-file',
+  'video-transcoding',
   'video-file-import',
   'video-import',
   'videos-views',
@@ -66,10 +68,10 @@ class JobQueue {
     if (this.initialized === true) return
     this.initialized = true
 
-    this.jobRedisPrefix = 'bull-' + CONFIG.WEBSERVER.HOST
+    this.jobRedisPrefix = 'bull-' + WEBSERVER.HOST
     const queueOptions = {
       prefix: this.jobRedisPrefix,
-      redis: Redis.getRedisClient(),
+      redis: Redis.getRedisClientOptions(),
       settings: {
         maxStalledCount: 10 // transcoding could be long, so jobs can often be interrupted by restarts
       }
diff --git a/server/lib/notifier.ts b/server/lib/notifier.ts
index 2fa320cd7..c1e63fa8f 100644
--- a/server/lib/notifier.ts
+++ b/server/lib/notifier.ts
@@ -6,7 +6,7 @@ import { UserNotificationModel } from '../models/account/user-notification'
 import { VideoCommentModel } from '../models/video/video-comment'
 import { UserModel } from '../models/account/user'
 import { PeerTubeSocket } from './peertube-socket'
-import { CONFIG } from '../initializers/constants'
+import { CONFIG } from '../initializers/config'
 import { VideoPrivacy, VideoState } from '../../shared/models/videos'
 import { VideoAbuseModel } from '../models/video/video-abuse'
 import { VideoBlacklistModel } from '../models/video/video-blacklist'
@@ -23,19 +23,35 @@ class Notifier {
   private constructor () {}
 
   notifyOnNewVideo (video: VideoModel): void {
-    // Only notify on public and published videos
-    if (video.privacy !== VideoPrivacy.PUBLIC || video.state !== VideoState.PUBLISHED) return
+    // Only notify on public and published videos which are not blacklisted
+    if (video.privacy !== VideoPrivacy.PUBLIC || video.state !== VideoState.PUBLISHED || video.VideoBlacklist) return
 
     this.notifySubscribersOfNewVideo(video)
       .catch(err => logger.error('Cannot notify subscribers of new video %s.', video.url, { err }))
   }
 
-  notifyOnPendingVideoPublished (video: VideoModel): void {
-    // Only notify on public videos that has been published while the user waited transcoding/scheduled update
-    if (video.waitTranscoding === false && !video.ScheduleVideoUpdate) return
+  notifyOnVideoPublishedAfterTranscoding (video: VideoModel): void {
+    // don't notify if didn't wait for transcoding or video is still blacklisted/waiting for scheduled update
+    if (!video.waitTranscoding || video.VideoBlacklist || video.ScheduleVideoUpdate) return
 
     this.notifyOwnedVideoHasBeenPublished(video)
-        .catch(err => logger.error('Cannot notify owner that its video %s has been published.', video.url, { err }))
+        .catch(err => logger.error('Cannot notify owner that its video %s has been published after transcoding.', video.url, { err }))
+  }
+
+  notifyOnVideoPublishedAfterScheduledUpdate (video: VideoModel): void {
+    // don't notify if video is still blacklisted or waiting for transcoding
+    if (video.VideoBlacklist || (video.waitTranscoding && video.state !== VideoState.PUBLISHED)) return
+
+    this.notifyOwnedVideoHasBeenPublished(video)
+        .catch(err => logger.error('Cannot notify owner that its video %s has been published after scheduled update.', video.url, { err }))
+  }
+
+  notifyOnVideoPublishedAfterRemovedFromAutoBlacklist (video: VideoModel): void {
+    // don't notify if video is still waiting for transcoding or scheduled update
+    if (video.ScheduleVideoUpdate || (video.waitTranscoding && video.state !== VideoState.PUBLISHED)) return
+
+    this.notifyOwnedVideoHasBeenPublished(video)
+        .catch(err => logger.error('Cannot notify owner that its video %s has been published after removed from auto-blacklist.', video.url, { err })) // tslint:disable-line:max-line-length
   }
 
   notifyOnNewComment (comment: VideoCommentModel): void {
@@ -51,6 +67,11 @@ class Notifier {
       .catch(err => logger.error('Cannot notify of new video abuse of video %s.', videoAbuse.Video.url, { err }))
   }
 
+  notifyOnVideoAutoBlacklist (video: VideoModel): void {
+    this.notifyModeratorsOfVideoAutoBlacklist(video)
+      .catch(err => logger.error('Cannot notify of auto-blacklist of video %s.', video.url, { err }))
+  }
+
   notifyOnVideoBlacklist (videoBlacklist: VideoBlacklistModel): void {
     this.notifyVideoOwnerOfBlacklist(videoBlacklist)
       .catch(err => logger.error('Cannot notify video owner of new video blacklist of %s.', videoBlacklist.Video.url, { err }))
@@ -58,7 +79,7 @@ class Notifier {
 
   notifyOnVideoUnblacklist (video: VideoModel): void {
     this.notifyVideoOwnerOfUnblacklist(video)
-        .catch(err => logger.error('Cannot notify video owner of new video blacklist of %s.', video.url, { err }))
+        .catch(err => logger.error('Cannot notify video owner of unblacklist of %s.', video.url, { err }))
   }
 
   notifyOnFinishedVideoImport (videoImport: VideoImportModel, success: boolean): void {
@@ -71,18 +92,25 @@ class Notifier {
         .catch(err => logger.error('Cannot notify moderators of new user registration (%s).', user.username, { err }))
   }
 
-  notifyOfNewFollow (actorFollow: ActorFollowModel): void {
+  notifyOfNewUserFollow (actorFollow: ActorFollowModel): void {
     this.notifyUserOfNewActorFollow(actorFollow)
       .catch(err => {
         logger.error(
           'Cannot notify owner of channel %s of a new follow by %s.',
           actorFollow.ActorFollowing.VideoChannel.getDisplayName(),
           actorFollow.ActorFollower.Account.getDisplayName(),
-          err
+          { err }
         )
       })
   }
 
+  notifyOfNewInstanceFollow (actorFollow: ActorFollowModel): void {
+    this.notifyAdminsOfNewInstanceFollow(actorFollow)
+        .catch(err => {
+          logger.error('Cannot notify administrators of new follower %s.', actorFollow.ActorFollower.url, { err })
+        })
+  }
+
   private async notifySubscribersOfNewVideo (video: VideoModel) {
     // List all followers that are users
     const users = await UserModel.listUserSubscribersOf(video.VideoChannel.actorId)
@@ -147,10 +175,13 @@ class Notifier {
   }
 
   private async notifyOfCommentMention (comment: VideoCommentModel) {
-    const usernames = comment.extractMentions()
-    logger.debug('Extracted %d username from comment %s.', usernames.length, comment.url, { usernames, text: comment.text })
+    const extractedUsernames = comment.extractMentions()
+    logger.debug(
+      'Extracted %d username from comment %s.', extractedUsernames.length, comment.url,
+      { usernames: extractedUsernames, text: comment.text }
+    )
 
-    let users = await UserModel.listByUsernames(usernames)
+    let users = await UserModel.listByUsernames(extractedUsernames)
 
     if (comment.Video.isOwned()) {
       const userException = await UserModel.loadByVideoId(comment.videoId)
@@ -237,6 +268,33 @@ class Notifier {
     return this.notify({ users: [ user ], settingGetter, notificationCreator, emailSender })
   }
 
+  private async notifyAdminsOfNewInstanceFollow (actorFollow: ActorFollowModel) {
+    const admins = await UserModel.listWithRight(UserRight.MANAGE_SERVER_FOLLOW)
+
+    logger.info('Notifying %d administrators of new instance follower: %s.', admins.length, actorFollow.ActorFollower.url)
+
+    function settingGetter (user: UserModel) {
+      return user.NotificationSetting.newInstanceFollower
+    }
+
+    async function notificationCreator (user: UserModel) {
+      const notification = await UserNotificationModel.create({
+        type: UserNotificationType.NEW_INSTANCE_FOLLOWER,
+        userId: user.id,
+        actorFollowId: actorFollow.id
+      })
+      notification.ActorFollow = actorFollow
+
+      return notification
+    }
+
+    function emailSender (emails: string[]) {
+      return Emailer.Instance.addNewInstanceFollowerNotification(emails, actorFollow)
+    }
+
+    return this.notify({ users: admins, settingGetter, notificationCreator, emailSender })
+  }
+
   private async notifyModeratorsOfNewVideoAbuse (videoAbuse: VideoAbuseModel) {
     const moderators = await UserModel.listWithRight(UserRight.MANAGE_VIDEO_ABUSES)
     if (moderators.length === 0) return
@@ -265,6 +323,34 @@ class Notifier {
     return this.notify({ users: moderators, settingGetter, notificationCreator, emailSender })
   }
 
+  private async notifyModeratorsOfVideoAutoBlacklist (video: VideoModel) {
+    const moderators = await UserModel.listWithRight(UserRight.MANAGE_VIDEO_BLACKLIST)
+    if (moderators.length === 0) return
+
+    logger.info('Notifying %s moderators of video auto-blacklist %s.', moderators.length, video.url)
+
+    function settingGetter (user: UserModel) {
+      return user.NotificationSetting.videoAutoBlacklistAsModerator
+    }
+    async function notificationCreator (user: UserModel) {
+
+      const notification = await UserNotificationModel.create({
+        type: UserNotificationType.VIDEO_AUTO_BLACKLIST_FOR_MODERATORS,
+        userId: user.id,
+        videoId: video.id
+      })
+      notification.Video = video
+
+      return notification
+    }
+
+    function emailSender (emails: string[]) {
+      return Emailer.Instance.addVideoAutoBlacklistModeratorsNotification(emails, video)
+    }
+
+    return this.notify({ users: moderators, settingGetter, notificationCreator, emailSender })
+  }
+
   private async notifyVideoOwnerOfBlacklist (videoBlacklist: VideoBlacklistModel) {
     const user = await UserModel.loadByVideoId(videoBlacklist.videoId)
     if (!user) return
@@ -436,7 +522,7 @@ class Notifier {
   }
 
   private isEmailEnabled (user: UserModel, value: UserNotificationSettingValue) {
-    if (CONFIG.SIGNUP.REQUIRES_EMAIL_VERIFICATION === true && user.emailVerified !== true) return false
+    if (CONFIG.SIGNUP.REQUIRES_EMAIL_VERIFICATION === true && user.emailVerified === false) return false
 
     return value & UserNotificationSettingValue.EMAIL
   }
diff --git a/server/lib/oauth-model.ts b/server/lib/oauth-model.ts
index 2cd2ae97c..45ac3e7c4 100644
--- a/server/lib/oauth-model.ts
+++ b/server/lib/oauth-model.ts
@@ -4,12 +4,13 @@ import { logger } from '../helpers/logger'
 import { UserModel } from '../models/account/user'
 import { OAuthClientModel } from '../models/oauth/oauth-client'
 import { OAuthTokenModel } from '../models/oauth/oauth-token'
-import { CONFIG } from '../initializers/constants'
+import { CACHE } from '../initializers/constants'
 import { Transaction } from 'sequelize'
+import { CONFIG } from '../initializers/config'
 
 type TokenInfo = { accessToken: string, refreshToken: string, accessTokenExpiresAt: Date, refreshTokenExpiresAt: Date }
-const accessTokenCache: { [ accessToken: string ]: OAuthTokenModel } = {}
-const userHavingToken: { [ userId: number ]: string } = {}
+let accessTokenCache: { [ accessToken: string ]: OAuthTokenModel } = {}
+let userHavingToken: { [ userId: number ]: string } = {}
 
 // ---------------------------------------------------------------------------
 
@@ -38,11 +39,19 @@ function clearCacheByToken (token: string) {
 function getAccessToken (bearerToken: string) {
   logger.debug('Getting access token (bearerToken: ' + bearerToken + ').')
 
+  if (!bearerToken) return Bluebird.resolve(undefined)
+
   if (accessTokenCache[bearerToken] !== undefined) return Bluebird.resolve(accessTokenCache[bearerToken])
 
   return OAuthTokenModel.getByTokenAndPopulateUser(bearerToken)
     .then(tokenModel => {
       if (tokenModel) {
+        // Reinit our cache
+        if (Object.keys(accessTokenCache).length > CACHE.USER_TOKENS.MAX_SIZE) {
+          accessTokenCache = {}
+          userHavingToken = {}
+        }
+
         accessTokenCache[ bearerToken ] = tokenModel
         userHavingToken[ tokenModel.userId ] = tokenModel.accessToken
       }
diff --git a/server/lib/redis.ts b/server/lib/redis.ts
index 3628c0583..f77d0b62c 100644
--- a/server/lib/redis.ts
+++ b/server/lib/redis.ts
@@ -3,12 +3,13 @@ import { createClient, RedisClient } from 'redis'
 import { logger } from '../helpers/logger'
 import { generateRandomString } from '../helpers/utils'
 import {
-  CONFIG,
   CONTACT_FORM_LIFETIME,
   USER_EMAIL_VERIFY_LIFETIME,
   USER_PASSWORD_RESET_LIFETIME,
-  VIDEO_VIEW_LIFETIME
-} from '../initializers'
+  VIDEO_VIEW_LIFETIME,
+  WEBSERVER
+} from '../initializers/constants'
+import { CONFIG } from '../initializers/config'
 
 type CachedRoute = {
   body: string,
@@ -30,7 +31,7 @@ class Redis {
     if (this.initialized === true) return
     this.initialized = true
 
-    this.client = createClient(Redis.getRedisClient())
+    this.client = createClient(Redis.getRedisClientOptions())
 
     this.client.on('error', err => {
       logger.error('Error in Redis client.', { err })
@@ -41,10 +42,10 @@ class Redis {
       this.client.auth(CONFIG.REDIS.AUTH)
     }
 
-    this.prefix = 'redis-' + CONFIG.WEBSERVER.HOST + '-'
+    this.prefix = 'redis-' + WEBSERVER.HOST + '-'
   }
 
-  static getRedisClient () {
+  static getRedisClientOptions () {
     return Object.assign({},
       (CONFIG.REDIS.AUTH && CONFIG.REDIS.AUTH != null) ? { password: CONFIG.REDIS.AUTH } : {},
       (CONFIG.REDIS.DB) ? { db: CONFIG.REDIS.DB } : {},
@@ -54,6 +55,14 @@ class Redis {
     )
   }
 
+  getClient () {
+    return this.client
+  }
+
+  getPrefix () {
+    return this.prefix
+  }
+
   /************* Forgot password *************/
 
   async setResetPasswordVerificationString (userId: number) {
@@ -88,7 +97,7 @@ class Redis {
     return this.setValue(this.generateContactFormKey(ip), '1', CONTACT_FORM_LIFETIME)
   }
 
-  async isContactFormIpExists (ip: string) {
+  async doesContactFormIpExist (ip: string) {
     return this.exists(this.generateContactFormKey(ip))
   }
 
@@ -98,7 +107,7 @@ class Redis {
     return this.setValue(this.generateViewKey(ip, videoUUID), '1', VIDEO_VIEW_LIFETIME)
   }
 
-  async isVideoIPViewExists (ip: string, videoUUID: string) {
+  async doesVideoIPViewExist (ip: string, videoUUID: string) {
     return this.exists(this.generateViewKey(ip, videoUUID))
   }
 
diff --git a/server/lib/schedulers/abstract-scheduler.ts b/server/lib/schedulers/abstract-scheduler.ts
index 86ea7aa38..0e6088911 100644
--- a/server/lib/schedulers/abstract-scheduler.ts
+++ b/server/lib/schedulers/abstract-scheduler.ts
@@ -1,4 +1,5 @@
 import { logger } from '../../helpers/logger'
+import * as Bluebird from 'bluebird'
 
 export abstract class AbstractScheduler {
 
@@ -30,5 +31,5 @@ export abstract class AbstractScheduler {
     }
   }
 
-  protected abstract internalExecute (): Promise<any>
+  protected abstract internalExecute (): Promise<any> | Bluebird<any>
 }
diff --git a/server/lib/schedulers/actor-follow-scheduler.ts b/server/lib/schedulers/actor-follow-scheduler.ts
index 3967be7f8..fdd3ad5fa 100644
--- a/server/lib/schedulers/actor-follow-scheduler.ts
+++ b/server/lib/schedulers/actor-follow-scheduler.ts
@@ -2,8 +2,8 @@ import { isTestInstance } from '../../helpers/core-utils'
 import { logger } from '../../helpers/logger'
 import { ActorFollowModel } from '../../models/activitypub/actor-follow'
 import { AbstractScheduler } from './abstract-scheduler'
-import { SCHEDULER_INTERVALS_MS } from '../../initializers'
-import { ActorFollowScoreCache } from '../cache'
+import { SCHEDULER_INTERVALS_MS } from '../../initializers/constants'
+import { ActorFollowScoreCache } from '../files-cache'
 
 export class ActorFollowScheduler extends AbstractScheduler {
 
diff --git a/server/lib/schedulers/remove-old-history-scheduler.ts b/server/lib/schedulers/remove-old-history-scheduler.ts
new file mode 100644
index 000000000..1b5ff8394
--- /dev/null
+++ b/server/lib/schedulers/remove-old-history-scheduler.ts
@@ -0,0 +1,32 @@
+import { logger } from '../../helpers/logger'
+import { AbstractScheduler } from './abstract-scheduler'
+import { SCHEDULER_INTERVALS_MS } from '../../initializers/constants'
+import { UserVideoHistoryModel } from '../../models/account/user-video-history'
+import { CONFIG } from '../../initializers/config'
+import { isTestInstance } from '../../helpers/core-utils'
+
+export class RemoveOldHistoryScheduler extends AbstractScheduler {
+
+  private static instance: AbstractScheduler
+
+  protected schedulerIntervalMs = SCHEDULER_INTERVALS_MS.removeOldHistory
+
+  private constructor () {
+    super()
+  }
+
+  protected internalExecute () {
+    if (CONFIG.HISTORY.VIDEOS.MAX_AGE === -1) return
+
+    logger.info('Removing old videos history.')
+
+    const now = new Date()
+    const beforeDate = new Date(now.getTime() - CONFIG.HISTORY.VIDEOS.MAX_AGE).toISOString()
+
+    return UserVideoHistoryModel.removeOldHistory(beforeDate)
+  }
+
+  static get Instance () {
+    return this.instance || (this.instance = new this())
+  }
+}
diff --git a/server/lib/schedulers/remove-old-jobs-scheduler.ts b/server/lib/schedulers/remove-old-jobs-scheduler.ts
index 4a4341ba9..0179a7618 100644
--- a/server/lib/schedulers/remove-old-jobs-scheduler.ts
+++ b/server/lib/schedulers/remove-old-jobs-scheduler.ts
@@ -2,7 +2,7 @@ import { isTestInstance } from '../../helpers/core-utils'
 import { logger } from '../../helpers/logger'
 import { JobQueue } from '../job-queue'
 import { AbstractScheduler } from './abstract-scheduler'
-import { SCHEDULER_INTERVALS_MS } from '../../initializers'
+import { SCHEDULER_INTERVALS_MS } from '../../initializers/constants'
 
 export class RemoveOldJobsScheduler extends AbstractScheduler {
 
diff --git a/server/lib/schedulers/remove-old-views-scheduler.ts b/server/lib/schedulers/remove-old-views-scheduler.ts
new file mode 100644
index 000000000..39fbb9163
--- /dev/null
+++ b/server/lib/schedulers/remove-old-views-scheduler.ts
@@ -0,0 +1,33 @@
+import { logger } from '../../helpers/logger'
+import { AbstractScheduler } from './abstract-scheduler'
+import { SCHEDULER_INTERVALS_MS } from '../../initializers/constants'
+import { UserVideoHistoryModel } from '../../models/account/user-video-history'
+import { CONFIG } from '../../initializers/config'
+import { isTestInstance } from '../../helpers/core-utils'
+import { VideoViewModel } from '../../models/video/video-views'
+
+export class RemoveOldViewsScheduler extends AbstractScheduler {
+
+  private static instance: AbstractScheduler
+
+  protected schedulerIntervalMs = SCHEDULER_INTERVALS_MS.removeOldViews
+
+  private constructor () {
+    super()
+  }
+
+  protected internalExecute () {
+    if (CONFIG.VIEWS.VIDEOS.REMOTE.MAX_AGE === -1) return
+
+    logger.info('Removing old videos views.')
+
+    const now = new Date()
+    const beforeDate = new Date(now.getTime() - CONFIG.VIEWS.VIDEOS.REMOTE.MAX_AGE).toISOString()
+
+    return VideoViewModel.removeOldRemoteViewsHistory(beforeDate)
+  }
+
+  static get Instance () {
+    return this.instance || (this.instance = new this())
+  }
+}
diff --git a/server/lib/schedulers/update-videos-scheduler.ts b/server/lib/schedulers/update-videos-scheduler.ts
index 2618a5857..80080a132 100644
--- a/server/lib/schedulers/update-videos-scheduler.ts
+++ b/server/lib/schedulers/update-videos-scheduler.ts
@@ -3,10 +3,11 @@ import { AbstractScheduler } from './abstract-scheduler'
 import { ScheduleVideoUpdateModel } from '../../models/video/schedule-video-update'
 import { retryTransactionWrapper } from '../../helpers/database-utils'
 import { federateVideoIfNeeded } from '../activitypub'
-import { SCHEDULER_INTERVALS_MS, sequelizeTypescript } from '../../initializers'
+import { SCHEDULER_INTERVALS_MS } from '../../initializers/constants'
 import { VideoPrivacy } from '../../../shared/models/videos'
 import { Notifier } from '../notifier'
 import { VideoModel } from '../../models/video/video'
+import { sequelizeTypescript } from '../../initializers/database'
 
 export class UpdateVideosScheduler extends AbstractScheduler {
 
@@ -57,7 +58,7 @@ export class UpdateVideosScheduler extends AbstractScheduler {
 
     for (const v of publishedVideos) {
       Notifier.Instance.notifyOnNewVideo(v)
-      Notifier.Instance.notifyOnPendingVideoPublished(v)
+      Notifier.Instance.notifyOnVideoPublishedAfterScheduledUpdate(v)
     }
   }
 
diff --git a/server/lib/schedulers/videos-redundancy-scheduler.ts b/server/lib/schedulers/videos-redundancy-scheduler.ts
index f643ee226..01af1e9d2 100644
--- a/server/lib/schedulers/videos-redundancy-scheduler.ts
+++ b/server/lib/schedulers/videos-redundancy-scheduler.ts
@@ -1,5 +1,5 @@
 import { AbstractScheduler } from './abstract-scheduler'
-import { CONFIG, REDUNDANCY, VIDEO_IMPORT_TIMEOUT } from '../../initializers'
+import { HLS_REDUNDANCY_DIRECTORY, REDUNDANCY, VIDEO_IMPORT_TIMEOUT, WEBSERVER } from '../../initializers/constants'
 import { logger } from '../../helpers/logger'
 import { VideosRedundancy } from '../../../shared/models/redundancy'
 import { VideoRedundancyModel } from '../../models/redundancy/video-redundancy'
@@ -9,9 +9,20 @@ import { join } from 'path'
 import { move } from 'fs-extra'
 import { getServerActor } from '../../helpers/utils'
 import { sendCreateCacheFile, sendUpdateCacheFile } from '../activitypub/send'
-import { getVideoCacheFileActivityPubUrl } from '../activitypub/url'
+import { getVideoCacheFileActivityPubUrl, getVideoCacheStreamingPlaylistActivityPubUrl } from '../activitypub/url'
 import { removeVideoRedundancy } from '../redundancy'
 import { getOrCreateVideoAndAccountAndChannel } from '../activitypub'
+import { VideoStreamingPlaylistModel } from '../../models/video/video-streaming-playlist'
+import { VideoModel } from '../../models/video/video'
+import { downloadPlaylistSegments } from '../hls'
+import { CONFIG } from '../../initializers/config'
+
+type CandidateToDuplicate = {
+  redundancy: VideosRedundancy,
+  video: VideoModel,
+  files: VideoFileModel[],
+  streamingPlaylists: VideoStreamingPlaylistModel[]
+}
 
 export class VideosRedundancyScheduler extends AbstractScheduler {
 
@@ -24,28 +35,32 @@ export class VideosRedundancyScheduler extends AbstractScheduler {
   }
 
   protected async internalExecute () {
-    for (const obj of CONFIG.REDUNDANCY.VIDEOS.STRATEGIES) {
-      logger.info('Running redundancy scheduler for strategy %s.', obj.strategy)
+    for (const redundancyConfig of CONFIG.REDUNDANCY.VIDEOS.STRATEGIES) {
+      logger.info('Running redundancy scheduler for strategy %s.', redundancyConfig.strategy)
 
       try {
-        const videoToDuplicate = await this.findVideoToDuplicate(obj)
+        const videoToDuplicate = await this.findVideoToDuplicate(redundancyConfig)
         if (!videoToDuplicate) continue
 
-        const videoFiles = videoToDuplicate.VideoFiles
-        videoFiles.forEach(f => f.Video = videoToDuplicate)
+        const candidateToDuplicate = {
+          video: videoToDuplicate,
+          redundancy: redundancyConfig,
+          files: videoToDuplicate.VideoFiles,
+          streamingPlaylists: videoToDuplicate.VideoStreamingPlaylists
+        }
 
-        await this.purgeCacheIfNeeded(obj, videoFiles)
+        await this.purgeCacheIfNeeded(candidateToDuplicate)
 
-        if (await this.isTooHeavy(obj, videoFiles)) {
+        if (await this.isTooHeavy(candidateToDuplicate)) {
           logger.info('Video %s is too big for our cache, skipping.', videoToDuplicate.url)
           continue
         }
 
-        logger.info('Will duplicate video %s in redundancy scheduler "%s".', videoToDuplicate.url, obj.strategy)
+        logger.info('Will duplicate video %s in redundancy scheduler "%s".', videoToDuplicate.url, redundancyConfig.strategy)
 
-        await this.createVideoRedundancy(obj, videoFiles)
+        await this.createVideoRedundancies(candidateToDuplicate)
       } catch (err) {
-        logger.error('Cannot run videos redundancy %s.', obj.strategy, { err })
+        logger.error('Cannot run videos redundancy %s.', redundancyConfig.strategy, { err })
       }
     }
 
@@ -63,25 +78,35 @@ export class VideosRedundancyScheduler extends AbstractScheduler {
 
     for (const redundancyModel of expired) {
       try {
-        await this.extendsOrDeleteRedundancy(redundancyModel)
+        const redundancyConfig = CONFIG.REDUNDANCY.VIDEOS.STRATEGIES.find(s => s.strategy === redundancyModel.strategy)
+        const candidate = {
+          redundancy: redundancyConfig,
+          video: null,
+          files: [],
+          streamingPlaylists: []
+        }
+
+        // If the administrator disabled the redundancy or decreased the cache size, remove this redundancy instead of extending it
+        if (!redundancyConfig || await this.isTooHeavy(candidate)) {
+          logger.info('Destroying redundancy %s because the cache size %s is too heavy.', redundancyModel.url, redundancyModel.strategy)
+          await removeVideoRedundancy(redundancyModel)
+        } else {
+          await this.extendsRedundancy(redundancyModel)
+        }
       } catch (err) {
-        logger.error('Cannot extend expiration of %s video from our redundancy system.', this.buildEntryLogId(redundancyModel))
+        logger.error(
+          'Cannot extend or remove expiration of %s video from our redundancy system.', this.buildEntryLogId(redundancyModel),
+          { err }
+        )
       }
     }
   }
 
-  private async extendsOrDeleteRedundancy (redundancyModel: VideoRedundancyModel) {
-    // Refresh the video, maybe it was deleted
-    const video = await this.loadAndRefreshVideo(redundancyModel.VideoFile.Video.url)
-
-    if (!video) {
-      logger.info('Destroying existing redundancy %s, because the associated video does not exist anymore.', redundancyModel.url)
-
-      await redundancyModel.destroy()
-      return
-    }
-
+  private async extendsRedundancy (redundancyModel: VideoRedundancyModel) {
     const redundancy = CONFIG.REDUNDANCY.VIDEOS.STRATEGIES.find(s => s.strategy === redundancyModel.strategy)
+    // Redundancy strategy disabled, remove our redundancy instead of extending expiration
+    if (!redundancy) await removeVideoRedundancy(redundancyModel)
+
     await this.extendsExpirationOf(redundancyModel, redundancy.minLifetime)
   }
 
@@ -112,49 +137,93 @@ export class VideosRedundancyScheduler extends AbstractScheduler {
     }
   }
 
-  private async createVideoRedundancy (redundancy: VideosRedundancy, filesToDuplicate: VideoFileModel[]) {
-    const serverActor = await getServerActor()
+  private async createVideoRedundancies (data: CandidateToDuplicate) {
+    const video = await this.loadAndRefreshVideo(data.video.url)
+
+    if (!video) {
+      logger.info('Video %s we want to duplicate does not existing anymore, skipping.', data.video.url)
 
-    for (const file of filesToDuplicate) {
-      const video = await this.loadAndRefreshVideo(file.Video.url)
+      return
+    }
 
+    for (const file of data.files) {
       const existingRedundancy = await VideoRedundancyModel.loadLocalByFileId(file.id)
       if (existingRedundancy) {
-        await this.extendsOrDeleteRedundancy(existingRedundancy)
+        await this.extendsRedundancy(existingRedundancy)
 
         continue
       }
 
-      if (!video) {
-        logger.info('Video %s we want to duplicate does not existing anymore, skipping.', file.Video.url)
+      await this.createVideoFileRedundancy(data.redundancy, video, file)
+    }
+
+    for (const streamingPlaylist of data.streamingPlaylists) {
+      const existingRedundancy = await VideoRedundancyModel.loadLocalByStreamingPlaylistId(streamingPlaylist.id)
+      if (existingRedundancy) {
+        await this.extendsRedundancy(existingRedundancy)
 
         continue
       }
 
-      logger.info('Duplicating %s - %d in videos redundancy with "%s" strategy.', video.url, file.resolution, redundancy.strategy)
+      await this.createStreamingPlaylistRedundancy(data.redundancy, video, streamingPlaylist)
+    }
+  }
 
-      const { baseUrlHttp, baseUrlWs } = video.getBaseUrls()
-      const magnetUri = video.generateMagnetUri(file, baseUrlHttp, baseUrlWs)
+  private async createVideoFileRedundancy (redundancy: VideosRedundancy, video: VideoModel, file: VideoFileModel) {
+    file.Video = video
 
-      const tmpPath = await downloadWebTorrentVideo({ magnetUri }, VIDEO_IMPORT_TIMEOUT)
+    const serverActor = await getServerActor()
 
-      const destPath = join(CONFIG.STORAGE.REDUNDANCY_DIR, video.getVideoFilename(file))
-      await move(tmpPath, destPath)
+    logger.info('Duplicating %s - %d in videos redundancy with "%s" strategy.', video.url, file.resolution, redundancy.strategy)
 
-      const createdModel = await VideoRedundancyModel.create({
-        expiresOn: this.buildNewExpiration(redundancy.minLifetime),
-        url: getVideoCacheFileActivityPubUrl(file),
-        fileUrl: video.getVideoRedundancyUrl(file, CONFIG.WEBSERVER.URL),
-        strategy: redundancy.strategy,
-        videoFileId: file.id,
-        actorId: serverActor.id
-      })
-      createdModel.VideoFile = file
+    const { baseUrlHttp, baseUrlWs } = video.getBaseUrls()
+    const magnetUri = video.generateMagnetUri(file, baseUrlHttp, baseUrlWs)
 
-      await sendCreateCacheFile(serverActor, createdModel)
+    const tmpPath = await downloadWebTorrentVideo({ magnetUri }, VIDEO_IMPORT_TIMEOUT)
 
-      logger.info('Duplicated %s - %d -> %s.', video.url, file.resolution, createdModel.url)
-    }
+    const destPath = join(CONFIG.STORAGE.REDUNDANCY_DIR, video.getVideoFilename(file))
+    await move(tmpPath, destPath)
+
+    const createdModel = await VideoRedundancyModel.create({
+      expiresOn: this.buildNewExpiration(redundancy.minLifetime),
+      url: getVideoCacheFileActivityPubUrl(file),
+      fileUrl: video.getVideoRedundancyUrl(file, WEBSERVER.URL),
+      strategy: redundancy.strategy,
+      videoFileId: file.id,
+      actorId: serverActor.id
+    })
+
+    createdModel.VideoFile = file
+
+    await sendCreateCacheFile(serverActor, video, createdModel)
+
+    logger.info('Duplicated %s - %d -> %s.', video.url, file.resolution, createdModel.url)
+  }
+
+  private async createStreamingPlaylistRedundancy (redundancy: VideosRedundancy, video: VideoModel, playlist: VideoStreamingPlaylistModel) {
+    playlist.Video = video
+
+    const serverActor = await getServerActor()
+
+    logger.info('Duplicating %s streaming playlist in videos redundancy with "%s" strategy.', video.url, redundancy.strategy)
+
+    const destDirectory = join(HLS_REDUNDANCY_DIRECTORY, video.uuid)
+    await downloadPlaylistSegments(playlist.playlistUrl, destDirectory, VIDEO_IMPORT_TIMEOUT)
+
+    const createdModel = await VideoRedundancyModel.create({
+      expiresOn: this.buildNewExpiration(redundancy.minLifetime),
+      url: getVideoCacheStreamingPlaylistActivityPubUrl(video, playlist),
+      fileUrl: playlist.getVideoRedundancyUrl(WEBSERVER.URL),
+      strategy: redundancy.strategy,
+      videoStreamingPlaylistId: playlist.id,
+      actorId: serverActor.id
+    })
+
+    createdModel.VideoStreamingPlaylist = playlist
+
+    await sendCreateCacheFile(serverActor, video, createdModel)
+
+    logger.info('Duplicated playlist %s -> %s.', playlist.playlistUrl, createdModel.url)
   }
 
   private async extendsExpirationOf (redundancy: VideoRedundancyModel, expiresAfterMs: number) {
@@ -168,8 +237,9 @@ export class VideosRedundancyScheduler extends AbstractScheduler {
     await sendUpdateCacheFile(serverActor, redundancy)
   }
 
-  private async purgeCacheIfNeeded (redundancy: VideosRedundancy, filesToDuplicate: VideoFileModel[]) {
-    while (this.isTooHeavy(redundancy, filesToDuplicate)) {
+  private async purgeCacheIfNeeded (candidateToDuplicate: CandidateToDuplicate) {
+    while (this.isTooHeavy(candidateToDuplicate)) {
+      const redundancy = candidateToDuplicate.redundancy
       const toDelete = await VideoRedundancyModel.loadOldestLocalThatAlreadyExpired(redundancy.strategy, redundancy.minLifetime)
       if (!toDelete) return
 
@@ -177,11 +247,11 @@ export class VideosRedundancyScheduler extends AbstractScheduler {
     }
   }
 
-  private async isTooHeavy (redundancy: VideosRedundancy, filesToDuplicate: VideoFileModel[]) {
-    const maxSize = redundancy.size
+  private async isTooHeavy (candidateToDuplicate: CandidateToDuplicate) {
+    const maxSize = candidateToDuplicate.redundancy.size
 
-    const totalDuplicated = await VideoRedundancyModel.getTotalDuplicated(redundancy.strategy)
-    const totalWillDuplicate = totalDuplicated + this.getTotalFileSizes(filesToDuplicate)
+    const totalDuplicated = await VideoRedundancyModel.getTotalDuplicated(candidateToDuplicate.redundancy.strategy)
+    const totalWillDuplicate = totalDuplicated + this.getTotalFileSizes(candidateToDuplicate.files, candidateToDuplicate.streamingPlaylists)
 
     return totalWillDuplicate > maxSize
   }
@@ -191,13 +261,15 @@ export class VideosRedundancyScheduler extends AbstractScheduler {
   }
 
   private buildEntryLogId (object: VideoRedundancyModel) {
-    return `${object.VideoFile.Video.url}-${object.VideoFile.resolution}`
+    if (object.VideoFile) return `${object.VideoFile.Video.url}-${object.VideoFile.resolution}`
+
+    return `${object.VideoStreamingPlaylist.playlistUrl}`
   }
 
-  private getTotalFileSizes (files: VideoFileModel[]) {
+  private getTotalFileSizes (files: VideoFileModel[], playlists: VideoStreamingPlaylistModel[]) {
     const fileReducer = (previous: number, current: VideoFileModel) => previous + current.size
 
-    return files.reduce(fileReducer, 0)
+    return files.reduce(fileReducer, 0) * playlists.length
   }
 
   private async loadAndRefreshVideo (videoUrl: string) {
diff --git a/server/lib/schedulers/youtube-dl-update-scheduler.ts b/server/lib/schedulers/youtube-dl-update-scheduler.ts
index aa027116d..aefe6aba4 100644
--- a/server/lib/schedulers/youtube-dl-update-scheduler.ts
+++ b/server/lib/schedulers/youtube-dl-update-scheduler.ts
@@ -1,5 +1,5 @@
 import { AbstractScheduler } from './abstract-scheduler'
-import { SCHEDULER_INTERVALS_MS } from '../../initializers'
+import { SCHEDULER_INTERVALS_MS } from '../../initializers/constants'
 import { updateYoutubeDLBinary } from '../../helpers/youtube-dl'
 
 export class YoutubeDlUpdateScheduler extends AbstractScheduler {
diff --git a/server/lib/thumbnail.ts b/server/lib/thumbnail.ts
new file mode 100644
index 000000000..950b14c3b
--- /dev/null
+++ b/server/lib/thumbnail.ts
@@ -0,0 +1,151 @@
+import { VideoFileModel } from '../models/video/video-file'
+import { generateImageFromVideoFile } from '../helpers/ffmpeg-utils'
+import { CONFIG } from '../initializers/config'
+import { PREVIEWS_SIZE, THUMBNAILS_SIZE } from '../initializers/constants'
+import { VideoModel } from '../models/video/video'
+import { ThumbnailModel } from '../models/video/thumbnail'
+import { ThumbnailType } from '../../shared/models/videos/thumbnail.type'
+import { processImage } from '../helpers/image-utils'
+import { join } from 'path'
+import { downloadImage } from '../helpers/requests'
+import { VideoPlaylistModel } from '../models/video/video-playlist'
+
+type ImageSize = { height: number, width: number }
+
+function createPlaylistMiniatureFromExisting (inputPath: string, playlist: VideoPlaylistModel, keepOriginal = false, size?: ImageSize) {
+  const { filename, outputPath, height, width, existingThumbnail } = buildMetadataFromPlaylist(playlist, size)
+  const type = ThumbnailType.MINIATURE
+
+  const thumbnailCreator = () => processImage(inputPath, outputPath, { width, height }, keepOriginal)
+  return createThumbnailFromFunction({ thumbnailCreator, filename, height, width, type, existingThumbnail })
+}
+
+function createPlaylistMiniatureFromUrl (fileUrl: string, playlist: VideoPlaylistModel, size?: ImageSize) {
+  const { filename, basePath, height, width, existingThumbnail } = buildMetadataFromPlaylist(playlist, size)
+  const type = ThumbnailType.MINIATURE
+
+  const thumbnailCreator = () => downloadImage(fileUrl, basePath, filename, { width, height })
+  return createThumbnailFromFunction({ thumbnailCreator, filename, height, width, type, existingThumbnail, fileUrl })
+}
+
+function createVideoMiniatureFromUrl (fileUrl: string, video: VideoModel, type: ThumbnailType, size?: ImageSize) {
+  const { filename, basePath, height, width, existingThumbnail } = buildMetadataFromVideo(video, type, size)
+  const thumbnailCreator = () => downloadImage(fileUrl, basePath, filename, { width, height })
+
+  return createThumbnailFromFunction({ thumbnailCreator, filename, height, width, type, existingThumbnail, fileUrl })
+}
+
+function createVideoMiniatureFromExisting (inputPath: string, video: VideoModel, type: ThumbnailType, size?: ImageSize) {
+  const { filename, outputPath, height, width, existingThumbnail } = buildMetadataFromVideo(video, type, size)
+  const thumbnailCreator = () => processImage(inputPath, outputPath, { width, height })
+
+  return createThumbnailFromFunction({ thumbnailCreator, filename, height, width, type, existingThumbnail })
+}
+
+function generateVideoMiniature (video: VideoModel, videoFile: VideoFileModel, type: ThumbnailType) {
+  const input = video.getVideoFilePath(videoFile)
+
+  const { filename, basePath, height, width, existingThumbnail } = buildMetadataFromVideo(video, type)
+  const thumbnailCreator = () => generateImageFromVideoFile(input, basePath, filename, { height, width })
+
+  return createThumbnailFromFunction({ thumbnailCreator, filename, height, width, type, existingThumbnail })
+}
+
+function createPlaceholderThumbnail (fileUrl: string, video: VideoModel, type: ThumbnailType, size: ImageSize) {
+  const { filename, height, width, existingThumbnail } = buildMetadataFromVideo(video, type, size)
+
+  const thumbnail = existingThumbnail ? existingThumbnail : new ThumbnailModel()
+
+  thumbnail.filename = filename
+  thumbnail.height = height
+  thumbnail.width = width
+  thumbnail.type = type
+  thumbnail.fileUrl = fileUrl
+
+  return thumbnail
+}
+
+// ---------------------------------------------------------------------------
+
+export {
+  generateVideoMiniature,
+  createVideoMiniatureFromUrl,
+  createVideoMiniatureFromExisting,
+  createPlaceholderThumbnail,
+  createPlaylistMiniatureFromUrl,
+  createPlaylistMiniatureFromExisting
+}
+
+function buildMetadataFromPlaylist (playlist: VideoPlaylistModel, size: ImageSize) {
+  const filename = playlist.generateThumbnailName()
+  const basePath = CONFIG.STORAGE.THUMBNAILS_DIR
+
+  return {
+    filename,
+    basePath,
+    existingThumbnail: playlist.Thumbnail,
+    outputPath: join(basePath, filename),
+    height: size ? size.height : THUMBNAILS_SIZE.height,
+    width: size ? size.width : THUMBNAILS_SIZE.width
+  }
+}
+
+function buildMetadataFromVideo (video: VideoModel, type: ThumbnailType, size?: ImageSize) {
+  const existingThumbnail = Array.isArray(video.Thumbnails)
+    ? video.Thumbnails.find(t => t.type === type)
+    : undefined
+
+  if (type === ThumbnailType.MINIATURE) {
+    const filename = video.generateThumbnailName()
+    const basePath = CONFIG.STORAGE.THUMBNAILS_DIR
+
+    return {
+      filename,
+      basePath,
+      existingThumbnail,
+      outputPath: join(basePath, filename),
+      height: size ? size.height : THUMBNAILS_SIZE.height,
+      width: size ? size.width : THUMBNAILS_SIZE.width
+    }
+  }
+
+  if (type === ThumbnailType.PREVIEW) {
+    const filename = video.generatePreviewName()
+    const basePath = CONFIG.STORAGE.PREVIEWS_DIR
+
+    return {
+      filename,
+      basePath,
+      existingThumbnail,
+      outputPath: join(basePath, filename),
+      height: size ? size.height : PREVIEWS_SIZE.height,
+      width: size ? size.width : PREVIEWS_SIZE.width
+    }
+  }
+
+  return undefined
+}
+
+async function createThumbnailFromFunction (parameters: {
+  thumbnailCreator: () => Promise<any>,
+  filename: string,
+  height: number,
+  width: number,
+  type: ThumbnailType,
+  fileUrl?: string,
+  existingThumbnail?: ThumbnailModel
+}) {
+  const { thumbnailCreator, filename, width, height, type, existingThumbnail, fileUrl = null } = parameters
+
+  const thumbnail = existingThumbnail ? existingThumbnail : new ThumbnailModel()
+
+  thumbnail.filename = filename
+  thumbnail.height = height
+  thumbnail.width = width
+  thumbnail.type = type
+  thumbnail.fileUrl = fileUrl
+
+  await thumbnailCreator()
+
+  return thumbnail
+}
diff --git a/server/lib/user.ts b/server/lib/user.ts
index a39ef6c3d..7badb3e72 100644
--- a/server/lib/user.ts
+++ b/server/lib/user.ts
@@ -1,18 +1,19 @@
 import * as Sequelize from 'sequelize'
 import * as uuidv4 from 'uuid/v4'
 import { ActivityPubActorType } from '../../shared/models/activitypub'
-import { sequelizeTypescript, SERVER_ACTOR_NAME } from '../initializers'
+import { SERVER_ACTOR_NAME } from '../initializers/constants'
 import { AccountModel } from '../models/account/account'
 import { UserModel } from '../models/account/user'
 import { buildActorInstance, getAccountActivityPubUrl, setAsyncActorKeys } from './activitypub'
 import { createVideoChannel } from './video-channel'
 import { VideoChannelModel } from '../models/video/video-channel'
-import { FilteredModelAttributes } from 'sequelize-typescript/lib/models/Model'
 import { ActorModel } from '../models/activitypub/actor'
 import { UserNotificationSettingModel } from '../models/account/user-notification-setting'
 import { UserNotificationSetting, UserNotificationSettingValue } from '../../shared/models/users'
+import { createWatchLaterPlaylist } from './video-playlist'
+import { sequelizeTypescript } from '../initializers/database'
 
-async function createUserAccountAndChannel (userToCreate: UserModel, validateUser = true) {
+async function createUserAccountAndChannelAndPlaylist (userToCreate: UserModel, validateUser = true) {
   const { user, account, videoChannel } = await sequelizeTypescript.transaction(async t => {
     const userOptions = {
       transaction: t,
@@ -38,7 +39,9 @@ async function createUserAccountAndChannel (userToCreate: UserModel, validateUse
     }
     const videoChannel = await createVideoChannel(videoChannelInfo, accountCreated, t)
 
-    return { user: userCreated, account: accountCreated, videoChannel }
+    const videoPlaylist = await createWatchLaterPlaylist(accountCreated, t)
+
+    return { user: userCreated, account: accountCreated, videoChannel, videoPlaylist }
   })
 
   const [ accountKeys, channelKeys ] = await Promise.all([
@@ -69,7 +72,7 @@ async function createLocalAccountWithoutKeys (
     userId,
     applicationId,
     actorId: actorInstanceCreated.id
-  } as FilteredModelAttributes<AccountModel>)
+  })
 
   const accountInstanceCreated = await accountInstance.save({ transaction: t })
   accountInstanceCreated.Actor = actorInstanceCreated
@@ -89,7 +92,7 @@ async function createApplicationActor (applicationId: number) {
 
 export {
   createApplicationActor,
-  createUserAccountAndChannel,
+  createUserAccountAndChannelAndPlaylist,
   createLocalAccountWithoutKeys
 }
 
@@ -103,10 +106,12 @@ function createDefaultUserNotificationSettings (user: UserModel, t: Sequelize.Tr
     myVideoImportFinished: UserNotificationSettingValue.WEB,
     myVideoPublished: UserNotificationSettingValue.WEB,
     videoAbuseAsModerator: UserNotificationSettingValue.WEB | UserNotificationSettingValue.EMAIL,
+    videoAutoBlacklistAsModerator: UserNotificationSettingValue.WEB | UserNotificationSettingValue.EMAIL,
     blacklistOnMyVideo: UserNotificationSettingValue.WEB | UserNotificationSettingValue.EMAIL,
     newUserRegistration: UserNotificationSettingValue.WEB,
     commentMention: UserNotificationSettingValue.WEB,
-    newFollow: UserNotificationSettingValue.WEB
+    newFollow: UserNotificationSettingValue.WEB,
+    newInstanceFollower: UserNotificationSettingValue.WEB
   }
 
   return UserNotificationSettingModel.create(values, { transaction: t })
diff --git a/server/lib/video-blacklist.ts b/server/lib/video-blacklist.ts
new file mode 100644
index 000000000..985b89e31
--- /dev/null
+++ b/server/lib/video-blacklist.ts
@@ -0,0 +1,33 @@
+import * as sequelize from 'sequelize'
+import { CONFIG } from '../initializers/config'
+import { UserRight, VideoBlacklistType } from '../../shared/models'
+import { VideoBlacklistModel } from '../models/video/video-blacklist'
+import { UserModel } from '../models/account/user'
+import { VideoModel } from '../models/video/video'
+import { logger } from '../helpers/logger'
+import { UserAdminFlag } from '../../shared/models/users/user-flag.model'
+
+async function autoBlacklistVideoIfNeeded (video: VideoModel, user: UserModel, transaction: sequelize.Transaction) {
+  if (!CONFIG.AUTO_BLACKLIST.VIDEOS.OF_USERS.ENABLED) return false
+
+  if (user.hasRight(UserRight.MANAGE_VIDEO_BLACKLIST) || user.hasAdminFlag(UserAdminFlag.BY_PASS_VIDEO_AUTO_BLACKLIST)) return false
+
+  const sequelizeOptions = { transaction }
+  const videoBlacklistToCreate = {
+    videoId: video.id,
+    unfederated: true,
+    reason: 'Auto-blacklisted. Moderator review required.',
+    type: VideoBlacklistType.AUTO_BEFORE_PUBLISHED
+  }
+  await VideoBlacklistModel.create(videoBlacklistToCreate, sequelizeOptions)
+
+  logger.info('Video %s auto-blacklisted.', video.uuid)
+
+  return true
+}
+
+// ---------------------------------------------------------------------------
+
+export {
+  autoBlacklistVideoIfNeeded
+}
diff --git a/server/lib/video-comment.ts b/server/lib/video-comment.ts
index 59bce7520..bfe22d225 100644
--- a/server/lib/video-comment.ts
+++ b/server/lib/video-comment.ts
@@ -28,7 +28,7 @@ async function createVideoComment (obj: {
     videoId: obj.video.id,
     accountId: obj.account.id,
     url: 'fake url'
-  }, { transaction: t, validate: false })
+  }, { transaction: t, validate: false } as any) // FIXME: sequelize typings
 
   comment.set('url', getVideoCommentActivityPubUrl(obj.video, comment))
 
diff --git a/server/lib/video-playlist.ts b/server/lib/video-playlist.ts
new file mode 100644
index 000000000..6e214e60f
--- /dev/null
+++ b/server/lib/video-playlist.ts
@@ -0,0 +1,29 @@
+import * as Sequelize from 'sequelize'
+import { AccountModel } from '../models/account/account'
+import { VideoPlaylistModel } from '../models/video/video-playlist'
+import { VideoPlaylistPrivacy } from '../../shared/models/videos/playlist/video-playlist-privacy.model'
+import { getVideoPlaylistActivityPubUrl } from './activitypub'
+import { VideoPlaylistType } from '../../shared/models/videos/playlist/video-playlist-type.model'
+
+async function createWatchLaterPlaylist (account: AccountModel, t: Sequelize.Transaction) {
+  const videoPlaylist = new VideoPlaylistModel({
+    name: 'Watch later',
+    privacy: VideoPlaylistPrivacy.PRIVATE,
+    type: VideoPlaylistType.WATCH_LATER,
+    ownerAccountId: account.id
+  })
+
+  videoPlaylist.url = getVideoPlaylistActivityPubUrl(videoPlaylist) // We use the UUID, so set the URL after building the object
+
+  await videoPlaylist.save({ transaction: t })
+
+  videoPlaylist.OwnerAccount = account
+
+  return videoPlaylist
+}
+
+// ---------------------------------------------------------------------------
+
+export {
+  createWatchLaterPlaylist
+}
diff --git a/server/lib/video-transcoding.ts b/server/lib/video-transcoding.ts
index 4460f46e4..0fe0ff12a 100644
--- a/server/lib/video-transcoding.ts
+++ b/server/lib/video-transcoding.ts
@@ -1,11 +1,15 @@
-import { CONFIG } from '../initializers'
-import { extname, join } from 'path'
-import { getVideoFileFPS, getVideoFileResolution, transcode } from '../helpers/ffmpeg-utils'
-import { copy, remove, move, stat } from 'fs-extra'
+import { HLS_STREAMING_PLAYLIST_DIRECTORY, P2P_MEDIA_LOADER_PEER_VERSION, WEBSERVER } from '../initializers/constants'
+import { join } from 'path'
+import { getVideoFileFPS, transcode } from '../helpers/ffmpeg-utils'
+import { ensureDir, move, remove, stat } from 'fs-extra'
 import { logger } from '../helpers/logger'
 import { VideoResolution } from '../../shared/models/videos'
 import { VideoFileModel } from '../models/video/video-file'
 import { VideoModel } from '../models/video/video'
+import { updateMasterHLSPlaylist, updateSha256Segments } from './hls'
+import { VideoStreamingPlaylistModel } from '../models/video/video-streaming-playlist'
+import { VideoStreamingPlaylistType } from '../../shared/models/videos/video-streaming-playlist.type'
+import { CONFIG } from '../initializers/config'
 
 async function optimizeVideofile (video: VideoModel, inputVideoFileArg?: VideoFileModel) {
   const videosDirectory = CONFIG.STORAGE.VIDEOS_DIR
@@ -17,7 +21,8 @@ async function optimizeVideofile (video: VideoModel, inputVideoFileArg?: VideoFi
 
   const transcodeOptions = {
     inputPath: videoInputPath,
-    outputPath: videoTranscodedPath
+    outputPath: videoTranscodedPath,
+    resolution: inputVideoFile.resolution
   }
 
   // Could be very long!
@@ -47,7 +52,7 @@ async function optimizeVideofile (video: VideoModel, inputVideoFileArg?: VideoFi
   }
 }
 
-async function transcodeOriginalVideofile (video: VideoModel, resolution: VideoResolution, isPortraitMode: boolean) {
+async function transcodeOriginalVideofile (video: VideoModel, resolution: VideoResolution, isPortrait: boolean) {
   const videosDirectory = CONFIG.STORAGE.VIDEOS_DIR
   const extname = '.mp4'
 
@@ -60,13 +65,13 @@ async function transcodeOriginalVideofile (video: VideoModel, resolution: VideoR
     size: 0,
     videoId: video.id
   })
-  const videoOutputPath = join(videosDirectory, video.getVideoFilename(newVideoFile))
+  const videoOutputPath = join(CONFIG.STORAGE.VIDEOS_DIR, video.getVideoFilename(newVideoFile))
 
   const transcodeOptions = {
     inputPath: videoInputPath,
     outputPath: videoOutputPath,
     resolution,
-    isPortraitMode
+    isPortraitMode: isPortrait
   }
 
   await transcode(transcodeOptions)
@@ -84,48 +89,44 @@ async function transcodeOriginalVideofile (video: VideoModel, resolution: VideoR
   video.VideoFiles.push(newVideoFile)
 }
 
-async function importVideoFile (video: VideoModel, inputFilePath: string) {
-  const { videoFileResolution } = await getVideoFileResolution(inputFilePath)
-  const { size } = await stat(inputFilePath)
-  const fps = await getVideoFileFPS(inputFilePath)
+async function generateHlsPlaylist (video: VideoModel, resolution: VideoResolution, isPortraitMode: boolean) {
+  const baseHlsDirectory = join(HLS_STREAMING_PLAYLIST_DIRECTORY, video.uuid)
+  await ensureDir(join(HLS_STREAMING_PLAYLIST_DIRECTORY, video.uuid))
 
-  let updatedVideoFile = new VideoFileModel({
-    resolution: videoFileResolution,
-    extname: extname(inputFilePath),
-    size,
-    fps,
-    videoId: video.id
-  })
-
-  const currentVideoFile = video.VideoFiles.find(videoFile => videoFile.resolution === updatedVideoFile.resolution)
+  const videoInputPath = join(CONFIG.STORAGE.VIDEOS_DIR, video.getVideoFilename(video.getOriginalFile()))
+  const outputPath = join(baseHlsDirectory, VideoStreamingPlaylistModel.getHlsPlaylistFilename(resolution))
 
-  if (currentVideoFile) {
-    // Remove old file and old torrent
-    await video.removeFile(currentVideoFile)
-    await video.removeTorrent(currentVideoFile)
-    // Remove the old video file from the array
-    video.VideoFiles = video.VideoFiles.filter(f => f !== currentVideoFile)
-
-    // Update the database
-    currentVideoFile.set('extname', updatedVideoFile.extname)
-    currentVideoFile.set('size', updatedVideoFile.size)
-    currentVideoFile.set('fps', updatedVideoFile.fps)
+  const transcodeOptions = {
+    inputPath: videoInputPath,
+    outputPath,
+    resolution,
+    isPortraitMode,
 
-    updatedVideoFile = currentVideoFile
+    hlsPlaylist: {
+      videoFilename: VideoStreamingPlaylistModel.getHlsVideoName(video.uuid, resolution)
+    }
   }
 
-  const outputPath = video.getVideoFilePath(updatedVideoFile)
-  await copy(inputFilePath, outputPath)
+  await transcode(transcodeOptions)
 
-  await video.createTorrentAndSetInfoHash(updatedVideoFile)
+  await updateMasterHLSPlaylist(video)
+  await updateSha256Segments(video)
 
-  await updatedVideoFile.save()
+  const playlistUrl = WEBSERVER.URL + VideoStreamingPlaylistModel.getHlsMasterPlaylistStaticPath(video.uuid)
 
-  video.VideoFiles.push(updatedVideoFile)
+  await VideoStreamingPlaylistModel.upsert({
+    videoId: video.id,
+    playlistUrl,
+    segmentsSha256Url: WEBSERVER.URL + VideoStreamingPlaylistModel.getHlsSha256SegmentsStaticPath(video.uuid),
+    p2pMediaLoaderInfohashes: VideoStreamingPlaylistModel.buildP2PMediaLoaderInfoHashes(playlistUrl, video.VideoFiles),
+    p2pMediaLoaderPeerVersion: P2P_MEDIA_LOADER_PEER_VERSION,
+
+    type: VideoStreamingPlaylistType.HLS
+  })
 }
 
 export {
+  generateHlsPlaylist,
   optimizeVideofile,
-  transcodeOriginalVideofile,
-  importVideoFile
+  transcodeOriginalVideofile
 }
diff --git a/server/middlewares/activitypub.ts b/server/middlewares/activitypub.ts
index 01e5dd24e..b1e5b5236 100644
--- a/server/middlewares/activitypub.ts
+++ b/server/middlewares/activitypub.ts
@@ -1,11 +1,9 @@
-import { eachSeries } from 'async'
-import { NextFunction, Request, RequestHandler, Response } from 'express'
+import { NextFunction, Request, Response } from 'express'
 import { ActivityPubSignature } from '../../shared'
 import { logger } from '../helpers/logger'
 import { isHTTPSignatureVerified, isJsonLDSignatureVerified, parseHTTPSignature } from '../helpers/peertube-crypto'
-import { ACCEPT_HEADERS, ACTIVITY_PUB, HTTP_SIGNATURE } from '../initializers'
+import { ACCEPT_HEADERS, ACTIVITY_PUB, HTTP_SIGNATURE } from '../initializers/constants'
 import { getOrCreateActorAndServerAndModel } from '../lib/activitypub'
-import { ActorModel } from '../models/activitypub/actor'
 import { loadActorUrlOrGetFromWebfinger } from '../helpers/webfinger'
 
 async function checkSignature (req: Request, res: Response, next: NextFunction) {
@@ -13,7 +11,7 @@ async function checkSignature (req: Request, res: Response, next: NextFunction)
     const httpSignatureChecked = await checkHttpSignature(req, res)
     if (httpSignatureChecked !== true) return
 
-    const actor: ActorModel = res.locals.signature.actor
+    const actor = res.locals.signature.actor
 
     // Forwarded activity
     const bodyActor = req.body.actor
@@ -30,23 +28,16 @@ async function checkSignature (req: Request, res: Response, next: NextFunction)
   }
 }
 
-function executeIfActivityPub (fun: RequestHandler | RequestHandler[]) {
-  return (req: Request, res: Response, next: NextFunction) => {
-    const accepted = req.accepts(ACCEPT_HEADERS)
-    if (accepted === false || ACTIVITY_PUB.POTENTIAL_ACCEPT_HEADERS.indexOf(accepted) === -1) {
-      return next()
-    }
-
-    logger.debug('ActivityPub request for %s.', req.url)
+function executeIfActivityPub (req: Request, res: Response, next: NextFunction) {
+  const accepted = req.accepts(ACCEPT_HEADERS)
+  if (accepted === false || ACTIVITY_PUB.POTENTIAL_ACCEPT_HEADERS.indexOf(accepted) === -1) {
+    // Bypass this route
+    return next('route')
+  }
 
-    if (Array.isArray(fun) === true) {
-      return eachSeries(fun as RequestHandler[], (f, cb) => {
-        f(req, res, cb)
-      }, next)
-    }
+  logger.debug('ActivityPub request for %s.', req.url)
 
-    return (fun as RequestHandler)(req, res, next)
-  }
+  return next()
 }
 
 // ---------------------------------------------------------------------------
@@ -83,6 +74,8 @@ async function checkHttpSignature (req: Request, res: Response) {
 
   const verified = isHTTPSignatureVerified(parsed, actor)
   if (verified !== true) {
+    logger.warn('Signature from %s is invalid', actorUrl, { parsed })
+
     res.sendStatus(403)
     return false
   }
diff --git a/server/middlewares/cache.ts b/server/middlewares/cache.ts
index 8ffe75700..ef8611875 100644
--- a/server/middlewares/cache.ts
+++ b/server/middlewares/cache.ts
@@ -1,72 +1,16 @@
-import * as express from 'express'
-import * as AsyncLock from 'async-lock'
-import { parseDuration } from '../helpers/core-utils'
 import { Redis } from '../lib/redis'
-import { logger } from '../helpers/logger'
+import * as apicache from 'apicache'
 
-const lock = new AsyncLock({ timeout: 5000 })
+// Ensure Redis is initialized
+Redis.Instance.init()
 
-function cacheRoute (lifetimeArg: string | number) {
-  return async function (req: express.Request, res: express.Response, next: express.NextFunction) {
-    const redisKey = Redis.Instance.generateCachedRouteKey(req)
-
-    try {
-      await lock.acquire(redisKey, async (done) => {
-        const cached = await Redis.Instance.getCachedRoute(req)
-
-        // Not cached
-        if (!cached) {
-          logger.debug('No cached results for route %s.', req.originalUrl)
-
-          const sendSave = res.send.bind(res)
-          const redirectSave = res.redirect.bind(res)
-
-          res.send = (body) => {
-            if (res.statusCode >= 200 && res.statusCode < 400) {
-              const contentType = res.get('content-type')
-              const lifetime = parseDuration(lifetimeArg)
-
-              Redis.Instance.setCachedRoute(req, body, lifetime, contentType, res.statusCode)
-                   .then(() => done())
-                   .catch(err => {
-                     logger.error('Cannot cache route.', { err })
-                     return done(err)
-                   })
-            } else {
-              done()
-            }
-
-            return sendSave(body)
-          }
-
-          res.redirect = url => {
-            done()
-
-            return redirectSave(url)
-          }
-
-          return next()
-        }
-
-        if (cached.contentType) res.set('content-type', cached.contentType)
-
-        if (cached.statusCode) {
-          const statusCode = parseInt(cached.statusCode, 10)
-          if (!isNaN(statusCode)) res.status(statusCode)
-        }
-
-        logger.debug('Use cached result for %s.', req.originalUrl)
-        res.send(cached.body).end()
-
-        return done()
-      })
-    } catch (err) {
-      logger.error('Cannot serve cached route.', { err })
-      return next()
-    }
-  }
+const options = {
+  redisClient: Redis.Instance.getClient(),
+  appendKey: () => Redis.Instance.getPrefix()
 }
 
+const cacheRoute = apicache.options(options).middleware
+
 // ---------------------------------------------------------------------------
 
 export {
diff --git a/server/middlewares/csp.ts b/server/middlewares/csp.ts
index 8b919af0d..d484b3021 100644
--- a/server/middlewares/csp.ts
+++ b/server/middlewares/csp.ts
@@ -1,5 +1,5 @@
 import * as helmet from 'helmet'
-import { CONFIG } from '../initializers/constants'
+import { CONFIG } from '../initializers/config'
 
 const baseDirectives = Object.assign({},
   {
@@ -16,24 +16,22 @@ const baseDirectives = Object.assign({},
     baseUri: ["'self'"],
     manifestSrc: ["'self'"],
     frameSrc: ["'self'"], // instead of deprecated child-src / self because of test-embed
-    workerSrc: ["'self'"] // instead of deprecated child-src
+    workerSrc: ["'self'", 'blob:'] // instead of deprecated child-src
   },
-  CONFIG.SERVICES['CSP-LOGGER'] ? { reportUri: CONFIG.SERVICES['CSP-LOGGER'] } : {},
+  CONFIG.CSP.REPORT_URI ? { reportUri: CONFIG.CSP.REPORT_URI } : {},
   CONFIG.WEBSERVER.SCHEME === 'https' ? { upgradeInsecureRequests: true } : {}
 )
 
 const baseCSP = helmet.contentSecurityPolicy({
   directives: baseDirectives,
   browserSniff: false,
-  reportOnly: true
+  reportOnly: CONFIG.CSP.REPORT_ONLY
 })
 
 const embedCSP = helmet.contentSecurityPolicy({
-  directives: Object.assign(baseDirectives, {
-    frameAncestors: ['*']
-  }),
+  directives: Object.assign({}, baseDirectives, { frameAncestors: ['*'] }),
   browserSniff: false, // assumes a modern browser, but allows CDN in front
-  reportOnly: true
+  reportOnly: CONFIG.CSP.REPORT_ONLY
 })
 
 // ---------------------------------------------------------------------------
diff --git a/server/middlewares/oauth.ts b/server/middlewares/oauth.ts
index 1d193d467..2b4e300e4 100644
--- a/server/middlewares/oauth.ts
+++ b/server/middlewares/oauth.ts
@@ -1,7 +1,7 @@
 import * as express from 'express'
 import * as OAuthServer from 'express-oauth-server'
 import 'express-validator'
-import { OAUTH_LIFETIME } from '../initializers'
+import { OAUTH_LIFETIME } from '../initializers/constants'
 import { logger } from '../helpers/logger'
 import { Socket } from 'socket.io'
 import { getAccessToken } from '../lib/oauth-model'
@@ -35,6 +35,8 @@ function authenticateSocket (socket: Socket, next: (err?: any) => void) {
 
   logger.debug('Checking socket access token %s.', accessToken)
 
+  if (!accessToken) return next(new Error('No access token provided'))
+
   getAccessToken(accessToken)
     .then(tokenDB => {
       const now = new Date()
diff --git a/server/middlewares/pagination.ts b/server/middlewares/pagination.ts
index 9b497b19e..83304940f 100644
--- a/server/middlewares/pagination.ts
+++ b/server/middlewares/pagination.ts
@@ -1,7 +1,7 @@
 import 'express-validator'
 import * as express from 'express'
 
-import { PAGINATION } from '../initializers'
+import { PAGINATION } from '../initializers/constants'
 
 function setDefaultPagination (req: express.Request, res: express.Response, next: express.NextFunction) {
   if (!req.query.start) req.query.start = 0
diff --git a/server/middlewares/user-right.ts b/server/middlewares/user-right.ts
index 7cea7aa1e..498e3d677 100644
--- a/server/middlewares/user-right.ts
+++ b/server/middlewares/user-right.ts
@@ -2,11 +2,10 @@ import * as express from 'express'
 import 'express-validator'
 import { UserRight } from '../../shared'
 import { logger } from '../helpers/logger'
-import { UserModel } from '../models/account/user'
 
 function ensureUserHasRight (userRight: UserRight) {
   return function (req: express.Request, res: express.Response, next: express.NextFunction) {
-    const user = res.locals.oauth.token.user as UserModel
+    const user = res.locals.oauth.token.user
     if (user.hasRight(userRight) === false) {
       const message = `User ${user.username} does not have right ${UserRight[userRight]} to access to ${req.path}.`
       logger.info(message)
diff --git a/server/middlewares/validators/account.ts b/server/middlewares/validators/account.ts
index b3a51e631..96e120a38 100644
--- a/server/middlewares/validators/account.ts
+++ b/server/middlewares/validators/account.ts
@@ -1,6 +1,6 @@
 import * as express from 'express'
 import { param } from 'express-validator/check'
-import { isAccountNameValid, isAccountNameWithHostExist, isLocalAccountNameExist } from '../../helpers/custom-validators/accounts'
+import { isAccountNameValid, doesAccountNameWithHostExist, doesLocalAccountNameExist } from '../../helpers/custom-validators/accounts'
 import { logger } from '../../helpers/logger'
 import { areValidationErrors } from './utils'
 
@@ -11,20 +11,20 @@ const localAccountValidator = [
     logger.debug('Checking localAccountValidator parameters', { parameters: req.params })
 
     if (areValidationErrors(req, res)) return
-    if (!await isLocalAccountNameExist(req.params.name, res)) return
+    if (!await doesLocalAccountNameExist(req.params.name, res)) return
 
     return next()
   }
 ]
 
-const accountsNameWithHostGetValidator = [
+const accountNameWithHostGetValidator = [
   param('accountName').exists().withMessage('Should have an account name with host'),
 
   async (req: express.Request, res: express.Response, next: express.NextFunction) => {
     logger.debug('Checking accountsNameWithHostGetValidator parameters', { parameters: req.params })
 
     if (areValidationErrors(req, res)) return
-    if (!await isAccountNameWithHostExist(req.params.accountName, res)) return
+    if (!await doesAccountNameWithHostExist(req.params.accountName, res)) return
 
     return next()
   }
@@ -34,5 +34,5 @@ const accountsNameWithHostGetValidator = [
 
 export {
   localAccountValidator,
-  accountsNameWithHostGetValidator
+  accountNameWithHostGetValidator
 }
diff --git a/server/middlewares/validators/activitypub/activity.ts b/server/middlewares/validators/activitypub/activity.ts
index 3f9057c0c..7582f65e7 100644
--- a/server/middlewares/validators/activitypub/activity.ts
+++ b/server/middlewares/validators/activitypub/activity.ts
@@ -2,7 +2,6 @@ import * as express from 'express'
 import { isRootActivityValid } from '../../../helpers/custom-validators/activitypub/activity'
 import { logger } from '../../../helpers/logger'
 import { getServerActor } from '../../../helpers/utils'
-import { ActorModel } from '../../../models/activitypub/actor'
 
 async function activityPubValidator (req: express.Request, res: express.Response, next: express.NextFunction) {
   logger.debug('Checking activity pub parameters')
@@ -13,7 +12,7 @@ async function activityPubValidator (req: express.Request, res: express.Response
   }
 
   const serverActor = await getServerActor()
-  const remoteActor = res.locals.signature.actor as ActorModel
+  const remoteActor = res.locals.signature.actor
   if (serverActor.id === remoteActor.id) {
     logger.error('Receiving request in INBOX by ourselves!', req.body)
     return res.status(409).end()
diff --git a/server/middlewares/validators/avatar.ts b/server/middlewares/validators/avatar.ts
index ddc14f531..bab3ed118 100644
--- a/server/middlewares/validators/avatar.ts
+++ b/server/middlewares/validators/avatar.ts
@@ -2,7 +2,7 @@ import * as express from 'express'
 import { body } from 'express-validator/check'
 import { isAvatarFile } from '../../helpers/custom-validators/users'
 import { areValidationErrors } from './utils'
-import { CONSTRAINTS_FIELDS } from '../../initializers'
+import { CONSTRAINTS_FIELDS } from '../../initializers/constants'
 import { logger } from '../../helpers/logger'
 import { cleanUpReqFiles } from '../../helpers/express-utils'
 
diff --git a/server/middlewares/validators/blocklist.ts b/server/middlewares/validators/blocklist.ts
index 109276c63..7c494de78 100644
--- a/server/middlewares/validators/blocklist.ts
+++ b/server/middlewares/validators/blocklist.ts
@@ -2,14 +2,13 @@ import { body, param } from 'express-validator/check'
 import * as express from 'express'
 import { logger } from '../../helpers/logger'
 import { areValidationErrors } from './utils'
-import { isAccountNameWithHostExist } from '../../helpers/custom-validators/accounts'
-import { UserModel } from '../../models/account/user'
+import { doesAccountNameWithHostExist } from '../../helpers/custom-validators/accounts'
 import { AccountBlocklistModel } from '../../models/account/account-blocklist'
 import { isHostValid } from '../../helpers/custom-validators/servers'
 import { ServerBlocklistModel } from '../../models/server/server-blocklist'
 import { ServerModel } from '../../models/server/server'
-import { CONFIG } from '../../initializers'
 import { getServerActor } from '../../helpers/utils'
+import { WEBSERVER } from '../../initializers/constants'
 
 const blockAccountValidator = [
   body('accountName').exists().withMessage('Should have an account name with host'),
@@ -18,9 +17,9 @@ const blockAccountValidator = [
     logger.debug('Checking blockAccountByAccountValidator parameters', { parameters: req.body })
 
     if (areValidationErrors(req, res)) return
-    if (!await isAccountNameWithHostExist(req.body.accountName, res)) return
+    if (!await doesAccountNameWithHostExist(req.body.accountName, res)) return
 
-    const user = res.locals.oauth.token.User as UserModel
+    const user = res.locals.oauth.token.User
     const accountToBlock = res.locals.account
 
     if (user.Account.id === accountToBlock.id) {
@@ -42,11 +41,11 @@ const unblockAccountByAccountValidator = [
     logger.debug('Checking unblockAccountByAccountValidator parameters', { parameters: req.params })
 
     if (areValidationErrors(req, res)) return
-    if (!await isAccountNameWithHostExist(req.params.accountName, res)) return
+    if (!await doesAccountNameWithHostExist(req.params.accountName, res)) return
 
-    const user = res.locals.oauth.token.User as UserModel
+    const user = res.locals.oauth.token.User
     const targetAccount = res.locals.account
-    if (!await isUnblockAccountExists(user.Account.id, targetAccount.id, res)) return
+    if (!await doesUnblockAccountExist(user.Account.id, targetAccount.id, res)) return
 
     return next()
   }
@@ -59,11 +58,11 @@ const unblockAccountByServerValidator = [
     logger.debug('Checking unblockAccountByServerValidator parameters', { parameters: req.params })
 
     if (areValidationErrors(req, res)) return
-    if (!await isAccountNameWithHostExist(req.params.accountName, res)) return
+    if (!await doesAccountNameWithHostExist(req.params.accountName, res)) return
 
     const serverActor = await getServerActor()
     const targetAccount = res.locals.account
-    if (!await isUnblockAccountExists(serverActor.Account.id, targetAccount.id, res)) return
+    if (!await doesUnblockAccountExist(serverActor.Account.id, targetAccount.id, res)) return
 
     return next()
   }
@@ -79,7 +78,7 @@ const blockServerValidator = [
 
     const host: string = req.body.host
 
-    if (host === CONFIG.WEBSERVER.HOST) {
+    if (host === WEBSERVER.HOST) {
       return res.status(409)
         .send({ error: 'You cannot block your own server.' })
         .end()
@@ -106,8 +105,8 @@ const unblockServerByAccountValidator = [
 
     if (areValidationErrors(req, res)) return
 
-    const user = res.locals.oauth.token.User as UserModel
-    if (!await isUnblockServerExists(user.Account.id, req.params.host, res)) return
+    const user = res.locals.oauth.token.User
+    if (!await doesUnblockServerExist(user.Account.id, req.params.host, res)) return
 
     return next()
   }
@@ -122,7 +121,7 @@ const unblockServerByServerValidator = [
     if (areValidationErrors(req, res)) return
 
     const serverActor = await getServerActor()
-    if (!await isUnblockServerExists(serverActor.Account.id, req.params.host, res)) return
+    if (!await doesUnblockServerExist(serverActor.Account.id, req.params.host, res)) return
 
     return next()
   }
@@ -141,7 +140,7 @@ export {
 
 // ---------------------------------------------------------------------------
 
-async function isUnblockAccountExists (accountId: number, targetAccountId: number, res: express.Response) {
+async function doesUnblockAccountExist (accountId: number, targetAccountId: number, res: express.Response) {
   const accountBlock = await AccountBlocklistModel.loadByAccountAndTarget(accountId, targetAccountId)
   if (!accountBlock) {
     res.status(404)
@@ -156,7 +155,7 @@ async function isUnblockAccountExists (accountId: number, targetAccountId: numbe
   return true
 }
 
-async function isUnblockServerExists (accountId: number, host: string, res: express.Response) {
+async function doesUnblockServerExist (accountId: number, host: string, res: express.Response) {
   const serverBlock = await ServerBlocklistModel.loadByAccountAndHost(accountId, host)
   if (!serverBlock) {
     res.status(404)
diff --git a/server/middlewares/validators/config.ts b/server/middlewares/validators/config.ts
index 90108fa82..d015fa6fe 100644
--- a/server/middlewares/validators/config.ts
+++ b/server/middlewares/validators/config.ts
@@ -2,6 +2,8 @@ import * as express from 'express'
 import { body } from 'express-validator/check'
 import { isUserNSFWPolicyValid, isUserVideoQuotaValid, isUserVideoQuotaDailyValid } from '../../helpers/custom-validators/users'
 import { logger } from '../../helpers/logger'
+import { CustomConfig } from '../../../shared/models/server/custom-config.model'
+import { Emailer } from '../../lib/emailer'
 import { areValidationErrors } from './utils'
 
 const customConfigUpdateValidator = [
@@ -42,15 +44,34 @@ const customConfigUpdateValidator = [
   body('import.videos.http.enabled').isBoolean().withMessage('Should have a valid import video http enabled boolean'),
   body('import.videos.torrent.enabled').isBoolean().withMessage('Should have a valid import video torrent enabled boolean'),
 
+  body('followers.instance.enabled').isBoolean().withMessage('Should have a valid followers of instance boolean'),
+  body('followers.instance.manualApproval').isBoolean().withMessage('Should have a valid manual approval boolean'),
+
   async (req: express.Request, res: express.Response, next: express.NextFunction) => {
     logger.debug('Checking customConfigUpdateValidator parameters', { parameters: req.body })
 
     if (areValidationErrors(req, res)) return
+    if (!checkInvalidConfigIfEmailDisabled(req.body as CustomConfig, res)) return
 
     return next()
   }
 ]
 
+// ---------------------------------------------------------------------------
+
 export {
   customConfigUpdateValidator
 }
+
+function checkInvalidConfigIfEmailDisabled (customConfig: CustomConfig, res: express.Response) {
+  if (Emailer.isEnabled()) return true
+
+  if (customConfig.signup.requiresEmailVerification === true) {
+    res.status(400)
+      .send({ error: 'Emailer is disabled but you require signup email verification.' })
+      .end()
+    return false
+  }
+
+  return true
+}
diff --git a/server/middlewares/validators/feeds.ts b/server/middlewares/validators/feeds.ts
index 969ce2526..e4f5c98fe 100644
--- a/server/middlewares/validators/feeds.ts
+++ b/server/middlewares/validators/feeds.ts
@@ -1,12 +1,12 @@
 import * as express from 'express'
 import { param, query } from 'express-validator/check'
-import { isAccountIdExist, isAccountNameValid, isAccountNameWithHostExist } from '../../helpers/custom-validators/accounts'
+import { doesAccountIdExist, isAccountNameValid, doesAccountNameWithHostExist } from '../../helpers/custom-validators/accounts'
 import { isIdOrUUIDValid } from '../../helpers/custom-validators/misc'
 import { logger } from '../../helpers/logger'
 import { areValidationErrors } from './utils'
 import { isValidRSSFeed } from '../../helpers/custom-validators/feeds'
-import { isVideoChannelIdExist, isVideoChannelNameWithHostExist } from '../../helpers/custom-validators/video-channels'
-import { isVideoExist } from '../../helpers/custom-validators/videos'
+import { doesVideoChannelIdExist, doesVideoChannelNameWithHostExist } from '../../helpers/custom-validators/video-channels'
+import { doesVideoExist } from '../../helpers/custom-validators/videos'
 import { isActorPreferredUsernameValid } from '../../helpers/custom-validators/activitypub/actor'
 
 const videoFeedsValidator = [
@@ -22,10 +22,10 @@ const videoFeedsValidator = [
 
     if (areValidationErrors(req, res)) return
 
-    if (req.query.accountId && !await isAccountIdExist(req.query.accountId, res)) return
-    if (req.query.videoChannelId && !await isVideoChannelIdExist(req.query.videoChannelId, res)) return
-    if (req.query.accountName && !await isAccountNameWithHostExist(req.query.accountName, res)) return
-    if (req.query.videoChannelName && !await isVideoChannelNameWithHostExist(req.query.videoChannelName, res)) return
+    if (req.query.accountId && !await doesAccountIdExist(req.query.accountId, res)) return
+    if (req.query.videoChannelId && !await doesVideoChannelIdExist(req.query.videoChannelId, res)) return
+    if (req.query.accountName && !await doesAccountNameWithHostExist(req.query.accountName, res)) return
+    if (req.query.videoChannelName && !await doesVideoChannelNameWithHostExist(req.query.videoChannelName, res)) return
 
     return next()
   }
@@ -41,7 +41,7 @@ const videoCommentsFeedsValidator = [
 
     if (areValidationErrors(req, res)) return
 
-    if (req.query.videoId && !await isVideoExist(req.query.videoId, res)) return
+    if (req.query.videoId && !await doesVideoExist(req.query.videoId, res)) return
 
     return next()
   }
diff --git a/server/middlewares/validators/follows.ts b/server/middlewares/validators/follows.ts
index 73fa28be9..2e5a02307 100644
--- a/server/middlewares/validators/follows.ts
+++ b/server/middlewares/validators/follows.ts
@@ -4,16 +4,19 @@ import { isTestInstance } from '../../helpers/core-utils'
 import { isEachUniqueHostValid, isHostValid } from '../../helpers/custom-validators/servers'
 import { logger } from '../../helpers/logger'
 import { getServerActor } from '../../helpers/utils'
-import { CONFIG, SERVER_ACTOR_NAME } from '../../initializers'
+import { SERVER_ACTOR_NAME, WEBSERVER } from '../../initializers/constants'
 import { ActorFollowModel } from '../../models/activitypub/actor-follow'
 import { areValidationErrors } from './utils'
+import { ActorModel } from '../../models/activitypub/actor'
+import { loadActorUrlOrGetFromWebfinger } from '../../helpers/webfinger'
+import { isValidActorHandle } from '../../helpers/custom-validators/activitypub/actor'
 
 const followValidator = [
   body('hosts').custom(isEachUniqueHostValid).withMessage('Should have an array of unique hosts'),
 
   (req: express.Request, res: express.Response, next: express.NextFunction) => {
     // Force https if the administrator wants to make friends
-    if (isTestInstance() === false && CONFIG.WEBSERVER.SCHEME === 'http') {
+    if (isTestInstance() === false && WEBSERVER.SCHEME === 'http') {
       return res.status(500)
         .json({
           error: 'Cannot follow on a non HTTPS web server.'
@@ -33,7 +36,7 @@ const removeFollowingValidator = [
   param('host').custom(isHostValid).withMessage('Should have a valid host'),
 
   async (req: express.Request, res: express.Response, next: express.NextFunction) => {
-    logger.debug('Checking unfollow parameters', { parameters: req.params })
+    logger.debug('Checking unfollowing parameters', { parameters: req.params })
 
     if (areValidationErrors(req, res)) return
 
@@ -44,7 +47,7 @@ const removeFollowingValidator = [
       return res
         .status(404)
         .json({
-          error: `Follower ${req.params.host} not found.`
+          error: `Following ${req.params.host} not found.`
         })
         .end()
     }
@@ -54,9 +57,57 @@ const removeFollowingValidator = [
   }
 ]
 
+const getFollowerValidator = [
+  param('nameWithHost').custom(isValidActorHandle).withMessage('Should have a valid nameWithHost'),
+
+  async (req: express.Request, res: express.Response, next: express.NextFunction) => {
+    logger.debug('Checking get follower parameters', { parameters: req.params })
+
+    if (areValidationErrors(req, res)) return
+
+    let follow: ActorFollowModel
+    try {
+      const actorUrl = await loadActorUrlOrGetFromWebfinger(req.params.nameWithHost)
+      const actor = await ActorModel.loadByUrl(actorUrl)
+
+      const serverActor = await getServerActor()
+      follow = await ActorFollowModel.loadByActorAndTarget(actor.id, serverActor.id)
+    } catch (err) {
+      logger.warn('Cannot get actor from handle.', { handle: req.params.nameWithHost, err })
+    }
+
+    if (!follow) {
+      return res
+        .status(404)
+        .json({
+          error: `Follower ${req.params.nameWithHost} not found.`
+        })
+        .end()
+    }
+
+    res.locals.follow = follow
+    return next()
+  }
+]
+
+const acceptOrRejectFollowerValidator = [
+  (req: express.Request, res: express.Response, next: express.NextFunction) => {
+    logger.debug('Checking accept/reject follower parameters', { parameters: req.params })
+
+    const follow = res.locals.follow
+    if (follow.state !== 'pending') {
+      return res.status(400).json({ error: 'Follow is not in pending state.' }).end()
+    }
+
+    return next()
+  }
+]
+
 // ---------------------------------------------------------------------------
 
 export {
   followValidator,
-  removeFollowingValidator
+  removeFollowingValidator,
+  getFollowerValidator,
+  acceptOrRejectFollowerValidator
 }
diff --git a/server/middlewares/validators/logs.ts b/server/middlewares/validators/logs.ts
new file mode 100644
index 000000000..7380c6edd
--- /dev/null
+++ b/server/middlewares/validators/logs.ts
@@ -0,0 +1,31 @@
+import * as express from 'express'
+import { logger } from '../../helpers/logger'
+import { areValidationErrors } from './utils'
+import { isDateValid } from '../../helpers/custom-validators/misc'
+import { query } from 'express-validator/check'
+import { isValidLogLevel } from '../../helpers/custom-validators/logs'
+
+const getLogsValidator = [
+  query('startDate')
+    .custom(isDateValid).withMessage('Should have a valid start date'),
+  query('level')
+    .optional()
+    .custom(isValidLogLevel).withMessage('Should have a valid level'),
+  query('endDate')
+    .optional()
+    .custom(isDateValid).withMessage('Should have a valid end date'),
+
+  (req: express.Request, res: express.Response, next: express.NextFunction) => {
+    logger.debug('Checking getLogsValidator parameters.', { parameters: req.query })
+
+    if (areValidationErrors(req, res)) return
+
+    return next()
+  }
+]
+
+// ---------------------------------------------------------------------------
+
+export {
+  getLogsValidator
+}
diff --git a/server/middlewares/validators/oembed.ts b/server/middlewares/validators/oembed.ts
index cd9b27b16..0bb908d0b 100644
--- a/server/middlewares/validators/oembed.ts
+++ b/server/middlewares/validators/oembed.ts
@@ -3,12 +3,12 @@ import { query } from 'express-validator/check'
 import { join } from 'path'
 import { isTestInstance } from '../../helpers/core-utils'
 import { isIdOrUUIDValid } from '../../helpers/custom-validators/misc'
-import { isVideoExist } from '../../helpers/custom-validators/videos'
+import { doesVideoExist } from '../../helpers/custom-validators/videos'
 import { logger } from '../../helpers/logger'
-import { CONFIG } from '../../initializers'
 import { areValidationErrors } from './utils'
+import { WEBSERVER } from '../../initializers/constants'
 
-const urlShouldStartWith = CONFIG.WEBSERVER.SCHEME + '://' + join(CONFIG.WEBSERVER.HOST, 'videos', 'watch') + '/'
+const urlShouldStartWith = WEBSERVER.SCHEME + '://' + join(WEBSERVER.HOST, 'videos', 'watch') + '/'
 const videoWatchRegex = new RegExp('([^/]+)$')
 const isURLOptions = {
   require_host: true,
@@ -52,7 +52,7 @@ const oembedValidator = [
                 .end()
     }
 
-    if (!await isVideoExist(videoId, res)) return
+    if (!await doesVideoExist(videoId, res)) return
 
     return next()
   }
diff --git a/server/middlewares/validators/redundancy.ts b/server/middlewares/validators/redundancy.ts
index c72ab78b2..76cf89c40 100644
--- a/server/middlewares/validators/redundancy.ts
+++ b/server/middlewares/validators/redundancy.ts
@@ -1,19 +1,15 @@
 import * as express from 'express'
 import 'express-validator'
-import { param, body } from 'express-validator/check'
+import { body, param } from 'express-validator/check'
 import { exists, isBooleanValid, isIdOrUUIDValid, toIntOrNull } from '../../helpers/custom-validators/misc'
-import { isVideoExist } from '../../helpers/custom-validators/videos'
+import { doesVideoExist } from '../../helpers/custom-validators/videos'
 import { logger } from '../../helpers/logger'
 import { areValidationErrors } from './utils'
-import { VideoModel } from '../../models/video/video'
 import { VideoRedundancyModel } from '../../models/redundancy/video-redundancy'
 import { isHostValid } from '../../helpers/custom-validators/servers'
-import { getServerActor } from '../../helpers/utils'
-import { ActorFollowModel } from '../../models/activitypub/actor-follow'
-import { SERVER_ACTOR_NAME } from '../../initializers'
 import { ServerModel } from '../../models/server/server'
 
-const videoRedundancyGetValidator = [
+const videoFileRedundancyGetValidator = [
   param('videoId').custom(isIdOrUUIDValid).not().isEmpty().withMessage('Should have a valid video id'),
   param('resolution')
     .customSanitizer(toIntOrNull)
@@ -24,12 +20,12 @@ const videoRedundancyGetValidator = [
     .custom(exists).withMessage('Should have a valid fps'),
 
   async (req: express.Request, res: express.Response, next: express.NextFunction) => {
-    logger.debug('Checking videoRedundancyGetValidator parameters', { parameters: req.params })
+    logger.debug('Checking videoFileRedundancyGetValidator parameters', { parameters: req.params })
 
     if (areValidationErrors(req, res)) return
-    if (!await isVideoExist(req.params.videoId, res)) return
+    if (!await doesVideoExist(req.params.videoId, res)) return
 
-    const video: VideoModel = res.locals.video
+    const video = res.locals.video
     const videoFile = video.VideoFiles.find(f => {
       return f.resolution === req.params.resolution && (!req.params.fps || f.fps === req.params.fps)
     })
@@ -38,7 +34,31 @@ const videoRedundancyGetValidator = [
     res.locals.videoFile = videoFile
 
     const videoRedundancy = await VideoRedundancyModel.loadLocalByFileId(videoFile.id)
-    if (!videoRedundancy)return res.status(404).json({ error: 'Video redundancy not found.' })
+    if (!videoRedundancy) return res.status(404).json({ error: 'Video redundancy not found.' })
+    res.locals.videoRedundancy = videoRedundancy
+
+    return next()
+  }
+]
+
+const videoPlaylistRedundancyGetValidator = [
+  param('videoId').custom(isIdOrUUIDValid).not().isEmpty().withMessage('Should have a valid video id'),
+  param('streamingPlaylistType').custom(exists).withMessage('Should have a valid streaming playlist type'),
+
+  async (req: express.Request, res: express.Response, next: express.NextFunction) => {
+    logger.debug('Checking videoPlaylistRedundancyGetValidator parameters', { parameters: req.params })
+
+    if (areValidationErrors(req, res)) return
+    if (!await doesVideoExist(req.params.videoId, res)) return
+
+    const video = res.locals.video
+    const videoStreamingPlaylist = video.VideoStreamingPlaylists.find(p => p === req.params.streamingPlaylistType)
+
+    if (!videoStreamingPlaylist) return res.status(404).json({ error: 'Video playlist not found.' })
+    res.locals.videoStreamingPlaylist = videoStreamingPlaylist
+
+    const videoRedundancy = await VideoRedundancyModel.loadLocalByStreamingPlaylistId(videoStreamingPlaylist.id)
+    if (!videoRedundancy) return res.status(404).json({ error: 'Video redundancy not found.' })
     res.locals.videoRedundancy = videoRedundancy
 
     return next()
@@ -75,6 +95,7 @@ const updateServerRedundancyValidator = [
 // ---------------------------------------------------------------------------
 
 export {
-  videoRedundancyGetValidator,
+  videoFileRedundancyGetValidator,
+  videoPlaylistRedundancyGetValidator,
   updateServerRedundancyValidator
 }
diff --git a/server/middlewares/validators/search.ts b/server/middlewares/validators/search.ts
index 6a95d6095..7816d229c 100644
--- a/server/middlewares/validators/search.ts
+++ b/server/middlewares/validators/search.ts
@@ -10,6 +10,9 @@ const videosSearchValidator = [
   query('startDate').optional().custom(isDateValid).withMessage('Should have a valid start date'),
   query('endDate').optional().custom(isDateValid).withMessage('Should have a valid end date'),
 
+  query('originallyPublishedStartDate').optional().custom(isDateValid).withMessage('Should have a valid published start date'),
+  query('originallyPublishedEndDate').optional().custom(isDateValid).withMessage('Should have a valid published end date'),
+
   query('durationMin').optional().isInt().withMessage('Should have a valid min duration'),
   query('durationMax').optional().isInt().withMessage('Should have a valid max duration'),
 
diff --git a/server/middlewares/validators/server.ts b/server/middlewares/validators/server.ts
index d85afc2ff..6eff8e9ee 100644
--- a/server/middlewares/validators/server.ts
+++ b/server/middlewares/validators/server.ts
@@ -7,7 +7,7 @@ import { body } from 'express-validator/check'
 import { isUserDisplayNameValid } from '../../helpers/custom-validators/users'
 import { Emailer } from '../../lib/emailer'
 import { Redis } from '../../lib/redis'
-import { CONFIG } from '../../initializers/constants'
+import { CONFIG } from '../../initializers/config'
 
 const serverGetValidator = [
   body('host').custom(isHostValid).withMessage('Should have a valid host'),
@@ -57,7 +57,7 @@ const contactAdministratorValidator = [
         .end()
     }
 
-    if (await Redis.Instance.isContactFormIpExists(req.ip)) {
+    if (await Redis.Instance.doesContactFormIpExist(req.ip)) {
       logger.info('Refusing a contact form by %s: already sent one recently.', req.ip)
 
       return res
diff --git a/server/middlewares/validators/sort.ts b/server/middlewares/validators/sort.ts
index 5ceda845f..b497798d1 100644
--- a/server/middlewares/validators/sort.ts
+++ b/server/middlewares/validators/sort.ts
@@ -1,4 +1,4 @@
-import { SORTABLE_COLUMNS } from '../../initializers'
+import { SORTABLE_COLUMNS } from '../../initializers/constants'
 import { checkSort, createSortableColumns } from './utils'
 
 // Initialize constants here for better performances
@@ -11,6 +11,7 @@ const SORTABLE_VIDEOS_SEARCH_COLUMNS = createSortableColumns(SORTABLE_COLUMNS.VI
 const SORTABLE_VIDEO_CHANNELS_SEARCH_COLUMNS = createSortableColumns(SORTABLE_COLUMNS.VIDEO_CHANNELS_SEARCH)
 const SORTABLE_VIDEO_IMPORTS_COLUMNS = createSortableColumns(SORTABLE_COLUMNS.VIDEO_IMPORTS)
 const SORTABLE_VIDEO_COMMENT_THREADS_COLUMNS = createSortableColumns(SORTABLE_COLUMNS.VIDEO_COMMENT_THREADS)
+const SORTABLE_VIDEO_RATES_COLUMNS = createSortableColumns(SORTABLE_COLUMNS.VIDEO_RATES)
 const SORTABLE_BLACKLISTS_COLUMNS = createSortableColumns(SORTABLE_COLUMNS.BLACKLISTS)
 const SORTABLE_VIDEO_CHANNELS_COLUMNS = createSortableColumns(SORTABLE_COLUMNS.VIDEO_CHANNELS)
 const SORTABLE_FOLLOWERS_COLUMNS = createSortableColumns(SORTABLE_COLUMNS.FOLLOWERS)
@@ -19,6 +20,7 @@ const SORTABLE_USER_SUBSCRIPTIONS_COLUMNS = createSortableColumns(SORTABLE_COLUM
 const SORTABLE_ACCOUNTS_BLOCKLIST_COLUMNS = createSortableColumns(SORTABLE_COLUMNS.ACCOUNTS_BLOCKLIST)
 const SORTABLE_SERVERS_BLOCKLIST_COLUMNS = createSortableColumns(SORTABLE_COLUMNS.SERVERS_BLOCKLIST)
 const SORTABLE_USER_NOTIFICATIONS_COLUMNS = createSortableColumns(SORTABLE_COLUMNS.USER_NOTIFICATIONS)
+const SORTABLE_VIDEO_PLAYLISTS_COLUMNS = createSortableColumns(SORTABLE_COLUMNS.VIDEO_PLAYLISTS)
 
 const usersSortValidator = checkSort(SORTABLE_USERS_COLUMNS)
 const accountsSortValidator = checkSort(SORTABLE_ACCOUNTS_COLUMNS)
@@ -29,6 +31,7 @@ const videoImportsSortValidator = checkSort(SORTABLE_VIDEO_IMPORTS_COLUMNS)
 const videosSearchSortValidator = checkSort(SORTABLE_VIDEOS_SEARCH_COLUMNS)
 const videoChannelsSearchSortValidator = checkSort(SORTABLE_VIDEO_CHANNELS_SEARCH_COLUMNS)
 const videoCommentThreadsSortValidator = checkSort(SORTABLE_VIDEO_COMMENT_THREADS_COLUMNS)
+const videoRatesSortValidator = checkSort(SORTABLE_VIDEO_RATES_COLUMNS)
 const blacklistSortValidator = checkSort(SORTABLE_BLACKLISTS_COLUMNS)
 const videoChannelsSortValidator = checkSort(SORTABLE_VIDEO_CHANNELS_COLUMNS)
 const followersSortValidator = checkSort(SORTABLE_FOLLOWERS_COLUMNS)
@@ -37,6 +40,7 @@ const userSubscriptionsSortValidator = checkSort(SORTABLE_USER_SUBSCRIPTIONS_COL
 const accountsBlocklistSortValidator = checkSort(SORTABLE_ACCOUNTS_BLOCKLIST_COLUMNS)
 const serversBlocklistSortValidator = checkSort(SORTABLE_SERVERS_BLOCKLIST_COLUMNS)
 const userNotificationsSortValidator = checkSort(SORTABLE_USER_NOTIFICATIONS_COLUMNS)
+const videoPlaylistsSortValidator = checkSort(SORTABLE_VIDEO_PLAYLISTS_COLUMNS)
 
 // ---------------------------------------------------------------------------
 
@@ -53,9 +57,11 @@ export {
   followingSortValidator,
   jobsSortValidator,
   videoCommentThreadsSortValidator,
+  videoRatesSortValidator,
   userSubscriptionsSortValidator,
   videoChannelsSearchSortValidator,
   accountsBlocklistSortValidator,
   serversBlocklistSortValidator,
-  userNotificationsSortValidator
+  userNotificationsSortValidator,
+  videoPlaylistsSortValidator
 }
diff --git a/server/middlewares/validators/user-notifications.ts b/server/middlewares/validators/user-notifications.ts
index 46486e081..3ded8d8cf 100644
--- a/server/middlewares/validators/user-notifications.ts
+++ b/server/middlewares/validators/user-notifications.ts
@@ -28,8 +28,22 @@ const updateNotificationSettingsValidator = [
     .custom(isUserNotificationSettingValid).withMessage('Should have a valid new comment on my video notification setting'),
   body('videoAbuseAsModerator')
     .custom(isUserNotificationSettingValid).withMessage('Should have a valid new video abuse as moderator notification setting'),
+  body('videoAutoBlacklistAsModerator')
+    .custom(isUserNotificationSettingValid).withMessage('Should have a valid video auto blacklist notification setting'),
   body('blacklistOnMyVideo')
     .custom(isUserNotificationSettingValid).withMessage('Should have a valid new blacklist on my video notification setting'),
+  body('myVideoImportFinished')
+    .custom(isUserNotificationSettingValid).withMessage('Should have a valid video import finished video notification setting'),
+  body('myVideoPublished')
+    .custom(isUserNotificationSettingValid).withMessage('Should have a valid video published notification setting'),
+  body('commentMention')
+    .custom(isUserNotificationSettingValid).withMessage('Should have a valid comment mention notification setting'),
+  body('newFollow')
+    .custom(isUserNotificationSettingValid).withMessage('Should have a valid new follow notification setting'),
+  body('newUserRegistration')
+    .custom(isUserNotificationSettingValid).withMessage('Should have a valid new user registration notification setting'),
+  body('newInstanceFollower')
+    .custom(isUserNotificationSettingValid).withMessage('Should have a valid new instance follower notification setting'),
 
   (req: express.Request, res: express.Response, next: express.NextFunction) => {
     logger.debug('Checking updateNotificationSettingsValidator parameters', { parameters: req.body })
diff --git a/server/middlewares/validators/user-subscriptions.ts b/server/middlewares/validators/user-subscriptions.ts
index c5f8d9d4c..2356745d7 100644
--- a/server/middlewares/validators/user-subscriptions.ts
+++ b/server/middlewares/validators/user-subscriptions.ts
@@ -5,9 +5,8 @@ import { logger } from '../../helpers/logger'
 import { areValidationErrors } from './utils'
 import { ActorFollowModel } from '../../models/activitypub/actor-follow'
 import { areValidActorHandles, isValidActorHandle } from '../../helpers/custom-validators/activitypub/actor'
-import { UserModel } from '../../models/account/user'
-import { CONFIG } from '../../initializers'
 import { toArray } from '../../helpers/custom-validators/misc'
+import { WEBSERVER } from '../../initializers/constants'
 
 const userSubscriptionAddValidator = [
   body('uri').custom(isValidActorHandle).withMessage('Should have a valid URI to follow (username@domain)'),
@@ -44,9 +43,9 @@ const userSubscriptionGetValidator = [
     if (areValidationErrors(req, res)) return
 
     let [ name, host ] = req.params.uri.split('@')
-    if (host === CONFIG.WEBSERVER.HOST) host = null
+    if (host === WEBSERVER.HOST) host = null
 
-    const user: UserModel = res.locals.oauth.token.User
+    const user = res.locals.oauth.token.User
     const subscription = await ActorFollowModel.loadByActorAndTargetNameAndHostForAPI(user.Account.Actor.id, name, host)
 
     if (!subscription || !subscription.ActorFollowing.VideoChannel) {
diff --git a/server/middlewares/validators/users.ts b/server/middlewares/validators/users.ts
index 1bb0bfb1b..6d8cd7894 100644
--- a/server/middlewares/validators/users.ts
+++ b/server/middlewares/validators/users.ts
@@ -5,6 +5,7 @@ import { body, param } from 'express-validator/check'
 import { omit } from 'lodash'
 import { isIdOrUUIDValid } from '../../helpers/custom-validators/misc'
 import {
+  isUserAdminFlagsValid,
   isUserAutoPlayVideoValid,
   isUserBlockedReasonValid,
   isUserDescriptionValid,
@@ -14,9 +15,10 @@ import {
   isUserRoleValid,
   isUserUsernameValid,
   isUserVideoQuotaDailyValid,
-  isUserVideoQuotaValid, isUserVideosHistoryEnabledValid
+  isUserVideoQuotaValid,
+  isUserVideosHistoryEnabledValid
 } from '../../helpers/custom-validators/users'
-import { isVideoExist } from '../../helpers/custom-validators/videos'
+import { doesVideoExist } from '../../helpers/custom-validators/videos'
 import { logger } from '../../helpers/logger'
 import { isSignupAllowed, isSignupAllowedForCurrentIP } from '../../helpers/signup'
 import { Redis } from '../../lib/redis'
@@ -31,6 +33,7 @@ const usersAddValidator = [
   body('videoQuota').custom(isUserVideoQuotaValid).withMessage('Should have a valid user quota'),
   body('videoQuotaDaily').custom(isUserVideoQuotaDailyValid).withMessage('Should have a valid daily user quota'),
   body('role').custom(isUserRoleValid).withMessage('Should have a valid role'),
+  body('adminFlags').optional().custom(isUserAdminFlagsValid).withMessage('Should have a valid admin flags'),
 
   async (req: express.Request, res: express.Response, next: express.NextFunction) => {
     logger.debug('Checking usersAdd parameters', { parameters: omit(req.body, 'password') })
@@ -100,7 +103,7 @@ const usersBlockingValidator = [
 
 const deleteMeValidator = [
   async (req: express.Request, res: express.Response, next: express.NextFunction) => {
-    const user: UserModel = res.locals.oauth.token.User
+    const user = res.locals.oauth.token.User
     if (user.username === 'root') {
       return res.status(400)
                 .send({ error: 'You cannot delete your root account.' })
@@ -113,11 +116,13 @@ const deleteMeValidator = [
 
 const usersUpdateValidator = [
   param('id').isInt().not().isEmpty().withMessage('Should have a valid id'),
+  body('password').optional().custom(isUserPasswordValid).withMessage('Should have a valid password'),
   body('email').optional().isEmail().withMessage('Should have a valid email attribute'),
   body('emailVerified').optional().isBoolean().withMessage('Should have a valid email verified attribute'),
   body('videoQuota').optional().custom(isUserVideoQuotaValid).withMessage('Should have a valid user quota'),
   body('videoQuotaDaily').optional().custom(isUserVideoQuotaDailyValid).withMessage('Should have a valid daily user quota'),
   body('role').optional().custom(isUserRoleValid).withMessage('Should have a valid role'),
+  body('adminFlags').optional().custom(isUserAdminFlagsValid).withMessage('Should have a valid admin flags'),
 
   async (req: express.Request, res: express.Response, next: express.NextFunction) => {
     logger.debug('Checking usersUpdate parameters', { parameters: req.body })
@@ -158,8 +163,7 @@ const usersUpdateMeValidator = [
                   .end()
       }
 
-      const user: UserModel = res.locals.oauth.token.User
-
+      const user = res.locals.oauth.token.User
       if (await user.isPasswordMatch(req.body.currentPassword) !== true) {
         return res.status(401)
                   .send({ error: 'currentPassword is invalid.' })
@@ -193,7 +197,7 @@ const usersVideoRatingValidator = [
     logger.debug('Checking usersVideoRating parameters', { parameters: req.params })
 
     if (areValidationErrors(req, res)) return
-    if (!await isVideoExist(req.params.videoId, res, 'id')) return
+    if (!await doesVideoExist(req.params.videoId, res, 'id')) return
 
     return next()
   }
@@ -233,6 +237,7 @@ const usersAskResetPasswordValidator = [
     logger.debug('Checking usersAskResetPassword parameters', { parameters: req.body })
 
     if (areValidationErrors(req, res)) return
+
     const exists = await checkUserEmailExist(req.body.email, res, false)
     if (!exists) {
       logger.debug('User with email %s does not exist (asking reset password).', req.body.email)
@@ -255,7 +260,7 @@ const usersResetPasswordValidator = [
     if (areValidationErrors(req, res)) return
     if (!await checkUserIdExist(req.params.id, res)) return
 
-    const user = res.locals.user as UserModel
+    const user = res.locals.user
     const redisVerificationString = await Redis.Instance.getResetPasswordLink(user.id)
 
     if (redisVerificationString !== req.body.verificationString) {
@@ -297,7 +302,7 @@ const usersVerifyEmailValidator = [
     if (areValidationErrors(req, res)) return
     if (!await checkUserIdExist(req.params.id, res)) return
 
-    const user = res.locals.user as UserModel
+    const user = res.locals.user
     const redisVerificationString = await Redis.Instance.getVerifyEmailLink(user.id)
 
     if (redisVerificationString !== req.body.verificationString) {
@@ -315,6 +320,20 @@ const userAutocompleteValidator = [
   param('search').isString().not().isEmpty().withMessage('Should have a search parameter')
 ]
 
+const ensureAuthUserOwnsAccountValidator = [
+  async (req: express.Request, res: express.Response, next: express.NextFunction) => {
+    const user = res.locals.oauth.token.User
+
+    if (res.locals.account.id !== user.Account.id) {
+      return res.status(403)
+                .send({ error: 'Only owner can access ratings list.' })
+                .end()
+    }
+
+    return next()
+  }
+]
+
 // ---------------------------------------------------------------------------
 
 export {
@@ -333,7 +352,8 @@ export {
   usersResetPasswordValidator,
   usersAskSendVerifyEmailValidator,
   usersVerifyEmailValidator,
-  userAutocompleteValidator
+  userAutocompleteValidator,
+  ensureAuthUserOwnsAccountValidator
 }
 
 // ---------------------------------------------------------------------------
diff --git a/server/middlewares/validators/videos/video-abuses.ts b/server/middlewares/validators/videos/video-abuses.ts
index be26ca16a..d1910a992 100644
--- a/server/middlewares/validators/videos/video-abuses.ts
+++ b/server/middlewares/validators/videos/video-abuses.ts
@@ -2,11 +2,11 @@ import * as express from 'express'
 import 'express-validator'
 import { body, param } from 'express-validator/check'
 import { isIdOrUUIDValid, isIdValid } from '../../../helpers/custom-validators/misc'
-import { isVideoExist } from '../../../helpers/custom-validators/videos'
+import { doesVideoExist } from '../../../helpers/custom-validators/videos'
 import { logger } from '../../../helpers/logger'
 import { areValidationErrors } from '../utils'
 import {
-  isVideoAbuseExist,
+  doesVideoAbuseExist,
   isVideoAbuseModerationCommentValid,
   isVideoAbuseReasonValid,
   isVideoAbuseStateValid
@@ -20,7 +20,7 @@ const videoAbuseReportValidator = [
     logger.debug('Checking videoAbuseReport parameters', { parameters: req.body })
 
     if (areValidationErrors(req, res)) return
-    if (!await isVideoExist(req.params.videoId, res)) return
+    if (!await doesVideoExist(req.params.videoId, res)) return
 
     return next()
   }
@@ -34,8 +34,8 @@ const videoAbuseGetValidator = [
     logger.debug('Checking videoAbuseGetValidator parameters', { parameters: req.body })
 
     if (areValidationErrors(req, res)) return
-    if (!await isVideoExist(req.params.videoId, res)) return
-    if (!await isVideoAbuseExist(req.params.id, res.locals.video.id, res)) return
+    if (!await doesVideoExist(req.params.videoId, res)) return
+    if (!await doesVideoAbuseExist(req.params.id, res.locals.video.id, res)) return
 
     return next()
   }
@@ -55,8 +55,8 @@ const videoAbuseUpdateValidator = [
     logger.debug('Checking videoAbuseUpdateValidator parameters', { parameters: req.body })
 
     if (areValidationErrors(req, res)) return
-    if (!await isVideoExist(req.params.videoId, res)) return
-    if (!await isVideoAbuseExist(req.params.id, res.locals.video.id, res)) return
+    if (!await doesVideoExist(req.params.videoId, res)) return
+    if (!await doesVideoAbuseExist(req.params.id, res.locals.video.id, res)) return
 
     return next()
   }
diff --git a/server/middlewares/validators/videos/video-blacklist.ts b/server/middlewares/validators/videos/video-blacklist.ts
index 2688f63ae..1d7ddb2e3 100644
--- a/server/middlewares/validators/videos/video-blacklist.ts
+++ b/server/middlewares/validators/videos/video-blacklist.ts
@@ -1,11 +1,14 @@
 import * as express from 'express'
-import { body, param } from 'express-validator/check'
+import { body, param, query } from 'express-validator/check'
 import { isBooleanValid, isIdOrUUIDValid } from '../../../helpers/custom-validators/misc'
-import { isVideoExist } from '../../../helpers/custom-validators/videos'
+import { doesVideoExist } from '../../../helpers/custom-validators/videos'
 import { logger } from '../../../helpers/logger'
 import { areValidationErrors } from '../utils'
-import { isVideoBlacklistExist, isVideoBlacklistReasonValid } from '../../../helpers/custom-validators/video-blacklist'
-import { VideoModel } from '../../../models/video/video'
+import {
+  doesVideoBlacklistExist,
+  isVideoBlacklistReasonValid,
+  isVideoBlacklistTypeValid
+} from '../../../helpers/custom-validators/video-blacklist'
 
 const videosBlacklistRemoveValidator = [
   param('videoId').custom(isIdOrUUIDValid).not().isEmpty().withMessage('Should have a valid videoId'),
@@ -14,8 +17,8 @@ const videosBlacklistRemoveValidator = [
     logger.debug('Checking blacklistRemove parameters.', { parameters: req.params })
 
     if (areValidationErrors(req, res)) return
-    if (!await isVideoExist(req.params.videoId, res)) return
-    if (!await isVideoBlacklistExist(res.locals.video.id, res)) return
+    if (!await doesVideoExist(req.params.videoId, res)) return
+    if (!await doesVideoBlacklistExist(res.locals.video.id, res)) return
 
     return next()
   }
@@ -35,9 +38,9 @@ const videosBlacklistAddValidator = [
     logger.debug('Checking videosBlacklistAdd parameters', { parameters: req.params })
 
     if (areValidationErrors(req, res)) return
-    if (!await isVideoExist(req.params.videoId, res)) return
+    if (!await doesVideoExist(req.params.videoId, res)) return
 
-    const video: VideoModel = res.locals.video
+    const video = res.locals.video
     if (req.body.unfederate === true && video.remote === true) {
       return res
         .status(409)
@@ -59,8 +62,22 @@ const videosBlacklistUpdateValidator = [
     logger.debug('Checking videosBlacklistUpdate parameters', { parameters: req.params })
 
     if (areValidationErrors(req, res)) return
-    if (!await isVideoExist(req.params.videoId, res)) return
-    if (!await isVideoBlacklistExist(res.locals.video.id, res)) return
+    if (!await doesVideoExist(req.params.videoId, res)) return
+    if (!await doesVideoBlacklistExist(res.locals.video.id, res)) return
+
+    return next()
+  }
+]
+
+const videosBlacklistFiltersValidator = [
+  query('type')
+    .optional()
+    .custom(isVideoBlacklistTypeValid).withMessage('Should have a valid video blacklist type attribute'),
+
+  (req: express.Request, res: express.Response, next: express.NextFunction) => {
+    logger.debug('Checking videos blacklist filters query', { parameters: req.query })
+
+    if (areValidationErrors(req, res)) return
 
     return next()
   }
@@ -71,5 +88,6 @@ const videosBlacklistUpdateValidator = [
 export {
   videosBlacklistAddValidator,
   videosBlacklistRemoveValidator,
-  videosBlacklistUpdateValidator
+  videosBlacklistUpdateValidator,
+  videosBlacklistFiltersValidator
 }
diff --git a/server/middlewares/validators/videos/video-captions.ts b/server/middlewares/validators/videos/video-captions.ts
index 63d84fbec..d857ac3ec 100644
--- a/server/middlewares/validators/videos/video-captions.ts
+++ b/server/middlewares/validators/videos/video-captions.ts
@@ -1,12 +1,12 @@
 import * as express from 'express'
 import { areValidationErrors } from '../utils'
-import { checkUserCanManageVideo, isVideoExist } from '../../../helpers/custom-validators/videos'
+import { checkUserCanManageVideo, doesVideoExist } from '../../../helpers/custom-validators/videos'
 import { isIdOrUUIDValid } from '../../../helpers/custom-validators/misc'
 import { body, param } from 'express-validator/check'
-import { CONSTRAINTS_FIELDS } from '../../../initializers'
+import { CONSTRAINTS_FIELDS } from '../../../initializers/constants'
 import { UserRight } from '../../../../shared'
 import { logger } from '../../../helpers/logger'
-import { isVideoCaptionExist, isVideoCaptionFile, isVideoCaptionLanguageValid } from '../../../helpers/custom-validators/video-captions'
+import { doesVideoCaptionExist, isVideoCaptionFile, isVideoCaptionLanguageValid } from '../../../helpers/custom-validators/video-captions'
 import { cleanUpReqFiles } from '../../../helpers/express-utils'
 
 const addVideoCaptionValidator = [
@@ -22,7 +22,7 @@ const addVideoCaptionValidator = [
     logger.debug('Checking addVideoCaption parameters', { parameters: req.body })
 
     if (areValidationErrors(req, res)) return cleanUpReqFiles(req)
-    if (!await isVideoExist(req.params.videoId, res)) return cleanUpReqFiles(req)
+    if (!await doesVideoExist(req.params.videoId, res)) return cleanUpReqFiles(req)
 
     // Check if the user who did the request is able to update the video
     const user = res.locals.oauth.token.User
@@ -40,8 +40,8 @@ const deleteVideoCaptionValidator = [
     logger.debug('Checking deleteVideoCaption parameters', { parameters: req.params })
 
     if (areValidationErrors(req, res)) return
-    if (!await isVideoExist(req.params.videoId, res)) return
-    if (!await isVideoCaptionExist(res.locals.video, req.params.captionLanguage, res)) return
+    if (!await doesVideoExist(req.params.videoId, res)) return
+    if (!await doesVideoCaptionExist(res.locals.video, req.params.captionLanguage, res)) return
 
     // Check if the user who did the request is able to update the video
     const user = res.locals.oauth.token.User
@@ -58,7 +58,7 @@ const listVideoCaptionsValidator = [
     logger.debug('Checking listVideoCaptions parameters', { parameters: req.params })
 
     if (areValidationErrors(req, res)) return
-    if (!await isVideoExist(req.params.videoId, res, 'id')) return
+    if (!await doesVideoExist(req.params.videoId, res, 'id')) return
 
     return next()
   }
diff --git a/server/middlewares/validators/videos/video-channels.ts b/server/middlewares/validators/videos/video-channels.ts
index f039794e0..4b26f0bc4 100644
--- a/server/middlewares/validators/videos/video-channels.ts
+++ b/server/middlewares/validators/videos/video-channels.ts
@@ -1,12 +1,11 @@
 import * as express from 'express'
 import { body, param } from 'express-validator/check'
 import { UserRight } from '../../../../shared'
-import { isAccountNameWithHostExist } from '../../../helpers/custom-validators/accounts'
 import {
-  isLocalVideoChannelNameExist,
+  doesLocalVideoChannelNameExist,
+  doesVideoChannelNameWithHostExist,
   isVideoChannelDescriptionValid,
   isVideoChannelNameValid,
-  isVideoChannelNameWithHostExist,
   isVideoChannelSupportValid
 } from '../../../helpers/custom-validators/video-channels'
 import { logger } from '../../../helpers/logger'
@@ -16,19 +15,6 @@ import { areValidationErrors } from '../utils'
 import { isActorPreferredUsernameValid } from '../../../helpers/custom-validators/activitypub/actor'
 import { ActorModel } from '../../../models/activitypub/actor'
 
-const listVideoAccountChannelsValidator = [
-  param('accountName').exists().withMessage('Should have a valid account name'),
-
-  async (req: express.Request, res: express.Response, next: express.NextFunction) => {
-    logger.debug('Checking listVideoAccountChannelsValidator parameters', { parameters: req.body })
-
-    if (areValidationErrors(req, res)) return
-    if (!await isAccountNameWithHostExist(req.params.accountName, res)) return
-
-    return next()
-  }
-]
-
 const videoChannelsAddValidator = [
   body('name').custom(isActorPreferredUsernameValid).withMessage('Should have a valid channel name'),
   body('displayName').custom(isVideoChannelNameValid).withMessage('Should have a valid display name'),
@@ -62,7 +48,7 @@ const videoChannelsUpdateValidator = [
     logger.debug('Checking videoChannelsUpdate parameters', { parameters: req.body })
 
     if (areValidationErrors(req, res)) return
-    if (!await isVideoChannelNameWithHostExist(req.params.nameWithHost, res)) return
+    if (!await doesVideoChannelNameWithHostExist(req.params.nameWithHost, res)) return
 
     // We need to make additional checks
     if (res.locals.videoChannel.Actor.isOwned() === false) {
@@ -88,7 +74,7 @@ const videoChannelsRemoveValidator = [
     logger.debug('Checking videoChannelsRemove parameters', { parameters: req.params })
 
     if (areValidationErrors(req, res)) return
-    if (!await isVideoChannelNameWithHostExist(req.params.nameWithHost, res)) return
+    if (!await doesVideoChannelNameWithHostExist(req.params.nameWithHost, res)) return
 
     if (!checkUserCanDeleteVideoChannel(res.locals.oauth.token.User, res.locals.videoChannel, res)) return
     if (!await checkVideoChannelIsNotTheLastOne(res)) return
@@ -105,7 +91,7 @@ const videoChannelsNameWithHostValidator = [
 
     if (areValidationErrors(req, res)) return
 
-    if (!await isVideoChannelNameWithHostExist(req.params.nameWithHost, res)) return
+    if (!await doesVideoChannelNameWithHostExist(req.params.nameWithHost, res)) return
 
     return next()
   }
@@ -118,7 +104,7 @@ const localVideoChannelValidator = [
     logger.debug('Checking localVideoChannelValidator parameters', { parameters: req.params })
 
     if (areValidationErrors(req, res)) return
-    if (!await isLocalVideoChannelNameExist(req.params.name, res)) return
+    if (!await doesLocalVideoChannelNameExist(req.params.name, res)) return
 
     return next()
   }
@@ -127,7 +113,6 @@ const localVideoChannelValidator = [
 // ---------------------------------------------------------------------------
 
 export {
-  listVideoAccountChannelsValidator,
   videoChannelsAddValidator,
   videoChannelsUpdateValidator,
   videoChannelsRemoveValidator,
diff --git a/server/middlewares/validators/videos/video-comments.ts b/server/middlewares/validators/videos/video-comments.ts
index 348d33082..ffde208b7 100644
--- a/server/middlewares/validators/videos/video-comments.ts
+++ b/server/middlewares/validators/videos/video-comments.ts
@@ -3,7 +3,7 @@ import { body, param } from 'express-validator/check'
 import { UserRight } from '../../../../shared'
 import { isIdOrUUIDValid, isIdValid } from '../../../helpers/custom-validators/misc'
 import { isValidVideoCommentText } from '../../../helpers/custom-validators/video-comments'
-import { isVideoExist } from '../../../helpers/custom-validators/videos'
+import { doesVideoExist } from '../../../helpers/custom-validators/videos'
 import { logger } from '../../../helpers/logger'
 import { UserModel } from '../../../models/account/user'
 import { VideoModel } from '../../../models/video/video'
@@ -17,7 +17,7 @@ const listVideoCommentThreadsValidator = [
     logger.debug('Checking listVideoCommentThreads parameters.', { parameters: req.params })
 
     if (areValidationErrors(req, res)) return
-    if (!await isVideoExist(req.params.videoId, res, 'only-video')) return
+    if (!await doesVideoExist(req.params.videoId, res, 'only-video')) return
 
     return next()
   }
@@ -31,8 +31,8 @@ const listVideoThreadCommentsValidator = [
     logger.debug('Checking listVideoThreadComments parameters.', { parameters: req.params })
 
     if (areValidationErrors(req, res)) return
-    if (!await isVideoExist(req.params.videoId, res, 'only-video')) return
-    if (!await isVideoCommentThreadExist(req.params.threadId, res.locals.video, res)) return
+    if (!await doesVideoExist(req.params.videoId, res, 'only-video')) return
+    if (!await doesVideoCommentThreadExist(req.params.threadId, res.locals.video, res)) return
 
     return next()
   }
@@ -46,7 +46,7 @@ const addVideoCommentThreadValidator = [
     logger.debug('Checking addVideoCommentThread parameters.', { parameters: req.params, body: req.body })
 
     if (areValidationErrors(req, res)) return
-    if (!await isVideoExist(req.params.videoId, res)) return
+    if (!await doesVideoExist(req.params.videoId, res)) return
     if (!isVideoCommentsEnabled(res.locals.video, res)) return
 
     return next()
@@ -62,9 +62,9 @@ const addVideoCommentReplyValidator = [
     logger.debug('Checking addVideoCommentReply parameters.', { parameters: req.params, body: req.body })
 
     if (areValidationErrors(req, res)) return
-    if (!await isVideoExist(req.params.videoId, res)) return
+    if (!await doesVideoExist(req.params.videoId, res)) return
     if (!isVideoCommentsEnabled(res.locals.video, res)) return
-    if (!await isVideoCommentExist(req.params.commentId, res.locals.video, res)) return
+    if (!await doesVideoCommentExist(req.params.commentId, res.locals.video, res)) return
 
     return next()
   }
@@ -78,8 +78,8 @@ const videoCommentGetValidator = [
     logger.debug('Checking videoCommentGetValidator parameters.', { parameters: req.params })
 
     if (areValidationErrors(req, res)) return
-    if (!await isVideoExist(req.params.videoId, res, 'id')) return
-    if (!await isVideoCommentExist(req.params.commentId, res.locals.video, res)) return
+    if (!await doesVideoExist(req.params.videoId, res, 'id')) return
+    if (!await doesVideoCommentExist(req.params.commentId, res.locals.video, res)) return
 
     return next()
   }
@@ -93,8 +93,8 @@ const removeVideoCommentValidator = [
     logger.debug('Checking removeVideoCommentValidator parameters.', { parameters: req.params })
 
     if (areValidationErrors(req, res)) return
-    if (!await isVideoExist(req.params.videoId, res)) return
-    if (!await isVideoCommentExist(req.params.commentId, res.locals.video, res)) return
+    if (!await doesVideoExist(req.params.videoId, res)) return
+    if (!await doesVideoCommentExist(req.params.commentId, res.locals.video, res)) return
 
     // Check if the user who did the request is able to delete the video
     if (!checkUserCanDeleteVideoComment(res.locals.oauth.token.User, res.locals.videoComment, res)) return
@@ -116,7 +116,7 @@ export {
 
 // ---------------------------------------------------------------------------
 
-async function isVideoCommentThreadExist (id: number, video: VideoModel, res: express.Response) {
+async function doesVideoCommentThreadExist (id: number, video: VideoModel, res: express.Response) {
   const videoComment = await VideoCommentModel.loadById(id)
 
   if (!videoComment) {
@@ -147,7 +147,7 @@ async function isVideoCommentThreadExist (id: number, video: VideoModel, res: ex
   return true
 }
 
-async function isVideoCommentExist (id: number, video: VideoModel, res: express.Response) {
+async function doesVideoCommentExist (id: number, video: VideoModel, res: express.Response) {
   const videoComment = await VideoCommentModel.loadByIdAndPopulateVideoAndAccountAndReply(id)
 
   if (!videoComment) {
diff --git a/server/middlewares/validators/videos/video-imports.ts b/server/middlewares/validators/videos/video-imports.ts
index 48d20f904..452084a7c 100644
--- a/server/middlewares/validators/videos/video-imports.ts
+++ b/server/middlewares/validators/videos/video-imports.ts
@@ -3,14 +3,14 @@ import { body } from 'express-validator/check'
 import { isIdValid } from '../../../helpers/custom-validators/misc'
 import { logger } from '../../../helpers/logger'
 import { areValidationErrors } from '../utils'
-import { getCommonVideoAttributes } from './videos'
+import { getCommonVideoEditAttributes } from './videos'
 import { isVideoImportTargetUrlValid, isVideoImportTorrentFile } from '../../../helpers/custom-validators/video-imports'
 import { cleanUpReqFiles } from '../../../helpers/express-utils'
-import { isVideoChannelOfAccountExist, isVideoMagnetUriValid, isVideoNameValid } from '../../../helpers/custom-validators/videos'
-import { CONFIG } from '../../../initializers/constants'
-import { CONSTRAINTS_FIELDS } from '../../../initializers'
+import { doesVideoChannelOfAccountExist, isVideoMagnetUriValid, isVideoNameValid } from '../../../helpers/custom-validators/videos'
+import { CONFIG } from '../../../initializers/config'
+import { CONSTRAINTS_FIELDS } from '../../../initializers/constants'
 
-const videoImportAddValidator = getCommonVideoAttributes().concat([
+const videoImportAddValidator = getCommonVideoEditAttributes().concat([
   body('channelId')
     .toInt()
     .custom(isIdValid).withMessage('Should have correct video channel id'),
@@ -51,7 +51,7 @@ const videoImportAddValidator = getCommonVideoAttributes().concat([
                 .end()
     }
 
-    if (!await isVideoChannelOfAccountExist(req.body.channelId, user, res)) return cleanUpReqFiles(req)
+    if (!await doesVideoChannelOfAccountExist(req.body.channelId, user, res)) return cleanUpReqFiles(req)
 
     // Check we have at least 1 required param
     if (!req.body.targetUrl && !req.body.magnetUri && !torrentFile) {
diff --git a/server/middlewares/validators/videos/video-playlists.ts b/server/middlewares/validators/videos/video-playlists.ts
new file mode 100644
index 000000000..2c3f7e542
--- /dev/null
+++ b/server/middlewares/validators/videos/video-playlists.ts
@@ -0,0 +1,408 @@
+import * as express from 'express'
+import { body, param, query, ValidationChain } from 'express-validator/check'
+import { UserRight, VideoPlaylistCreate, VideoPlaylistUpdate } from '../../../../shared'
+import { logger } from '../../../helpers/logger'
+import { UserModel } from '../../../models/account/user'
+import { areValidationErrors } from '../utils'
+import { doesVideoExist, isVideoImage } from '../../../helpers/custom-validators/videos'
+import { CONSTRAINTS_FIELDS } from '../../../initializers/constants'
+import { isArrayOf, isIdOrUUIDValid, isIdValid, isUUIDValid, toIntArray, toValueOrNull } from '../../../helpers/custom-validators/misc'
+import {
+  doesVideoPlaylistExist,
+  isVideoPlaylistDescriptionValid,
+  isVideoPlaylistNameValid,
+  isVideoPlaylistPrivacyValid,
+  isVideoPlaylistTimestampValid,
+  isVideoPlaylistTypeValid
+} from '../../../helpers/custom-validators/video-playlists'
+import { VideoPlaylistModel } from '../../../models/video/video-playlist'
+import { cleanUpReqFiles } from '../../../helpers/express-utils'
+import { doesVideoChannelIdExist } from '../../../helpers/custom-validators/video-channels'
+import { VideoPlaylistElementModel } from '../../../models/video/video-playlist-element'
+import { authenticatePromiseIfNeeded } from '../../oauth'
+import { VideoPlaylistPrivacy } from '../../../../shared/models/videos/playlist/video-playlist-privacy.model'
+import { VideoPlaylistType } from '../../../../shared/models/videos/playlist/video-playlist-type.model'
+
+const videoPlaylistsAddValidator = getCommonPlaylistEditAttributes().concat([
+  async (req: express.Request, res: express.Response, next: express.NextFunction) => {
+    logger.debug('Checking videoPlaylistsAddValidator parameters', { parameters: req.body })
+
+    if (areValidationErrors(req, res)) return cleanUpReqFiles(req)
+
+    const body: VideoPlaylistCreate = req.body
+    if (body.videoChannelId && !await doesVideoChannelIdExist(body.videoChannelId, res)) return cleanUpReqFiles(req)
+
+    if (body.privacy === VideoPlaylistPrivacy.PUBLIC && !body.videoChannelId) {
+      cleanUpReqFiles(req)
+      return res.status(400)
+                .json({ error: 'Cannot set "public" a playlist that is not assigned to a channel.' })
+    }
+
+    return next()
+  }
+])
+
+const videoPlaylistsUpdateValidator = getCommonPlaylistEditAttributes().concat([
+  param('playlistId')
+    .custom(isIdOrUUIDValid).withMessage('Should have a valid playlist id/uuid'),
+
+  async (req: express.Request, res: express.Response, next: express.NextFunction) => {
+    logger.debug('Checking videoPlaylistsUpdateValidator parameters', { parameters: req.body })
+
+    if (areValidationErrors(req, res)) return cleanUpReqFiles(req)
+
+    if (!await doesVideoPlaylistExist(req.params.playlistId, res, 'all')) return cleanUpReqFiles(req)
+
+    const videoPlaylist = res.locals.videoPlaylist
+
+    if (!checkUserCanManageVideoPlaylist(res.locals.oauth.token.User, res.locals.videoPlaylist, UserRight.REMOVE_ANY_VIDEO_PLAYLIST, res)) {
+      return cleanUpReqFiles(req)
+    }
+
+    const body: VideoPlaylistUpdate = req.body
+
+    if (videoPlaylist.privacy !== VideoPlaylistPrivacy.PRIVATE && body.privacy === VideoPlaylistPrivacy.PRIVATE) {
+      cleanUpReqFiles(req)
+      return res.status(400)
+                .json({ error: 'Cannot set "private" a video playlist that was not private.' })
+    }
+
+    const newPrivacy = body.privacy || videoPlaylist.privacy
+    if (newPrivacy === VideoPlaylistPrivacy.PUBLIC &&
+      (
+        (!videoPlaylist.videoChannelId && !body.videoChannelId) ||
+        body.videoChannelId === null
+      )
+    ) {
+      cleanUpReqFiles(req)
+      return res.status(400)
+                .json({ error: 'Cannot set "public" a playlist that is not assigned to a channel.' })
+    }
+
+    if (videoPlaylist.type === VideoPlaylistType.WATCH_LATER) {
+      cleanUpReqFiles(req)
+      return res.status(400)
+                .json({ error: 'Cannot update a watch later playlist.' })
+    }
+
+    if (body.videoChannelId && !await doesVideoChannelIdExist(body.videoChannelId, res)) return cleanUpReqFiles(req)
+
+    return next()
+  }
+])
+
+const videoPlaylistsDeleteValidator = [
+  param('playlistId')
+    .custom(isIdOrUUIDValid).withMessage('Should have a valid playlist id/uuid'),
+
+  async (req: express.Request, res: express.Response, next: express.NextFunction) => {
+    logger.debug('Checking videoPlaylistsDeleteValidator parameters', { parameters: req.params })
+
+    if (areValidationErrors(req, res)) return
+
+    if (!await doesVideoPlaylistExist(req.params.playlistId, res)) return
+
+    const videoPlaylist = res.locals.videoPlaylist
+    if (videoPlaylist.type === VideoPlaylistType.WATCH_LATER) {
+      return res.status(400)
+                .json({ error: 'Cannot delete a watch later playlist.' })
+    }
+
+    if (!checkUserCanManageVideoPlaylist(res.locals.oauth.token.User, res.locals.videoPlaylist, UserRight.REMOVE_ANY_VIDEO_PLAYLIST, res)) {
+      return
+    }
+
+    return next()
+  }
+]
+
+const videoPlaylistsGetValidator = [
+  param('playlistId')
+    .custom(isIdOrUUIDValid).withMessage('Should have a valid playlist id/uuid'),
+
+  async (req: express.Request, res: express.Response, next: express.NextFunction) => {
+    logger.debug('Checking videoPlaylistsGetValidator parameters', { parameters: req.params })
+
+    if (areValidationErrors(req, res)) return
+
+    if (!await doesVideoPlaylistExist(req.params.playlistId, res)) return
+
+    const videoPlaylist = res.locals.videoPlaylist
+
+    // Video is unlisted, check we used the uuid to fetch it
+    if (videoPlaylist.privacy === VideoPlaylistPrivacy.UNLISTED) {
+      if (isUUIDValid(req.params.playlistId)) return next()
+
+      return res.status(404).end()
+    }
+
+    if (videoPlaylist.privacy === VideoPlaylistPrivacy.PRIVATE) {
+      await authenticatePromiseIfNeeded(req, res)
+
+      const user = res.locals.oauth ? res.locals.oauth.token.User : null
+      if (
+        !user ||
+        (videoPlaylist.OwnerAccount.userId !== user.id && !user.hasRight(UserRight.UPDATE_ANY_VIDEO_PLAYLIST))
+      ) {
+        return res.status(403)
+                  .json({ error: 'Cannot get this private video playlist.' })
+      }
+
+      return next()
+    }
+
+    return next()
+  }
+]
+
+const videoPlaylistsAddVideoValidator = [
+  param('playlistId')
+    .custom(isIdOrUUIDValid).withMessage('Should have a valid playlist id/uuid'),
+  body('videoId')
+    .custom(isIdOrUUIDValid).withMessage('Should have a valid video id/uuid'),
+  body('startTimestamp')
+    .optional()
+    .custom(isVideoPlaylistTimestampValid).withMessage('Should have a valid start timestamp'),
+  body('stopTimestamp')
+    .optional()
+    .custom(isVideoPlaylistTimestampValid).withMessage('Should have a valid stop timestamp'),
+
+  async (req: express.Request, res: express.Response, next: express.NextFunction) => {
+    logger.debug('Checking videoPlaylistsAddVideoValidator parameters', { parameters: req.params })
+
+    if (areValidationErrors(req, res)) return
+
+    if (!await doesVideoPlaylistExist(req.params.playlistId, res, 'all')) return
+    if (!await doesVideoExist(req.body.videoId, res, 'only-video')) return
+
+    const videoPlaylist = res.locals.videoPlaylist
+    const video = res.locals.video
+
+    const videoPlaylistElement = await VideoPlaylistElementModel.loadByPlaylistAndVideo(videoPlaylist.id, video.id)
+    if (videoPlaylistElement) {
+      res.status(409)
+         .json({ error: 'This video in this playlist already exists' })
+         .end()
+
+      return
+    }
+
+    if (!checkUserCanManageVideoPlaylist(res.locals.oauth.token.User, res.locals.videoPlaylist, UserRight.UPDATE_ANY_VIDEO_PLAYLIST, res)) {
+      return
+    }
+
+    return next()
+  }
+]
+
+const videoPlaylistsUpdateOrRemoveVideoValidator = [
+  param('playlistId')
+    .custom(isIdOrUUIDValid).withMessage('Should have a valid playlist id/uuid'),
+  param('videoId')
+    .custom(isIdOrUUIDValid).withMessage('Should have an video id/uuid'),
+  body('startTimestamp')
+    .optional()
+    .custom(isVideoPlaylistTimestampValid).withMessage('Should have a valid start timestamp'),
+  body('stopTimestamp')
+    .optional()
+    .custom(isVideoPlaylistTimestampValid).withMessage('Should have a valid stop timestamp'),
+
+  async (req: express.Request, res: express.Response, next: express.NextFunction) => {
+    logger.debug('Checking videoPlaylistsRemoveVideoValidator parameters', { parameters: req.params })
+
+    if (areValidationErrors(req, res)) return
+
+    if (!await doesVideoPlaylistExist(req.params.playlistId, res, 'all')) return
+    if (!await doesVideoExist(req.params.videoId, res, 'id')) return
+
+    const videoPlaylist = res.locals.videoPlaylist
+    const video = res.locals.video
+
+    const videoPlaylistElement = await VideoPlaylistElementModel.loadByPlaylistAndVideo(videoPlaylist.id, video.id)
+    if (!videoPlaylistElement) {
+      res.status(404)
+         .json({ error: 'Video playlist element not found' })
+         .end()
+
+      return
+    }
+    res.locals.videoPlaylistElement = videoPlaylistElement
+
+    if (!checkUserCanManageVideoPlaylist(res.locals.oauth.token.User, videoPlaylist, UserRight.UPDATE_ANY_VIDEO_PLAYLIST, res)) return
+
+    return next()
+  }
+]
+
+const videoPlaylistElementAPGetValidator = [
+  param('playlistId')
+    .custom(isIdOrUUIDValid).withMessage('Should have a valid playlist id/uuid'),
+  param('videoId')
+    .custom(isIdOrUUIDValid).withMessage('Should have an video id/uuid'),
+
+  async (req: express.Request, res: express.Response, next: express.NextFunction) => {
+    logger.debug('Checking videoPlaylistElementAPGetValidator parameters', { parameters: req.params })
+
+    if (areValidationErrors(req, res)) return
+
+    const videoPlaylistElement = await VideoPlaylistElementModel.loadByPlaylistAndVideoForAP(req.params.playlistId, req.params.videoId)
+    if (!videoPlaylistElement) {
+      res.status(404)
+         .json({ error: 'Video playlist element not found' })
+         .end()
+
+      return
+    }
+
+    if (videoPlaylistElement.VideoPlaylist.privacy === VideoPlaylistPrivacy.PRIVATE) {
+      return res.status(403).end()
+    }
+
+    res.locals.videoPlaylistElement = videoPlaylistElement
+
+    return next()
+  }
+]
+
+const videoPlaylistsReorderVideosValidator = [
+  param('playlistId')
+    .custom(isIdOrUUIDValid).withMessage('Should have a valid playlist id/uuid'),
+  body('startPosition')
+    .isInt({ min: 1 }).withMessage('Should have a valid start position'),
+  body('insertAfterPosition')
+    .isInt({ min: 0 }).withMessage('Should have a valid insert after position'),
+  body('reorderLength')
+    .optional()
+    .isInt({ min: 1 }).withMessage('Should have a valid range length'),
+
+  async (req: express.Request, res: express.Response, next: express.NextFunction) => {
+    logger.debug('Checking videoPlaylistsReorderVideosValidator parameters', { parameters: req.params })
+
+    if (areValidationErrors(req, res)) return
+
+    if (!await doesVideoPlaylistExist(req.params.playlistId, res, 'all')) return
+
+    const videoPlaylist = res.locals.videoPlaylist
+    if (!checkUserCanManageVideoPlaylist(res.locals.oauth.token.User, videoPlaylist, UserRight.UPDATE_ANY_VIDEO_PLAYLIST, res)) return
+
+    const nextPosition = await VideoPlaylistElementModel.getNextPositionOf(videoPlaylist.id)
+    const startPosition: number = req.body.startPosition
+    const insertAfterPosition: number = req.body.insertAfterPosition
+    const reorderLength: number = req.body.reorderLength
+
+    if (startPosition >= nextPosition || insertAfterPosition >= nextPosition) {
+      res.status(400)
+         .json({ error: `Start position or insert after position exceed the playlist limits (max: ${nextPosition - 1})` })
+         .end()
+
+      return
+    }
+
+    if (reorderLength && reorderLength + startPosition > nextPosition) {
+      res.status(400)
+         .json({ error: `Reorder length with this start position exceeds the playlist limits (max: ${nextPosition - startPosition})` })
+         .end()
+
+      return
+    }
+
+    return next()
+  }
+]
+
+const commonVideoPlaylistFiltersValidator = [
+  query('playlistType')
+    .optional()
+    .custom(isVideoPlaylistTypeValid).withMessage('Should have a valid playlist type'),
+
+  (req: express.Request, res: express.Response, next: express.NextFunction) => {
+    logger.debug('Checking commonVideoPlaylistFiltersValidator parameters', { parameters: req.params })
+
+    if (areValidationErrors(req, res)) return
+
+    return next()
+  }
+]
+
+const doVideosInPlaylistExistValidator = [
+  query('videoIds')
+    .customSanitizer(toIntArray)
+    .custom(v => isArrayOf(v, isIdValid)).withMessage('Should have a valid video ids array'),
+
+  (req: express.Request, res: express.Response, next: express.NextFunction) => {
+    logger.debug('Checking areVideosInPlaylistExistValidator parameters', { parameters: req.query })
+
+    if (areValidationErrors(req, res)) return
+
+    return next()
+  }
+]
+
+// ---------------------------------------------------------------------------
+
+export {
+  videoPlaylistsAddValidator,
+  videoPlaylistsUpdateValidator,
+  videoPlaylistsDeleteValidator,
+  videoPlaylistsGetValidator,
+
+  videoPlaylistsAddVideoValidator,
+  videoPlaylistsUpdateOrRemoveVideoValidator,
+  videoPlaylistsReorderVideosValidator,
+
+  videoPlaylistElementAPGetValidator,
+
+  commonVideoPlaylistFiltersValidator,
+
+  doVideosInPlaylistExistValidator
+}
+
+// ---------------------------------------------------------------------------
+
+function getCommonPlaylistEditAttributes () {
+  return [
+    body('thumbnailfile')
+      .custom((value, { req }) => isVideoImage(req.files, 'thumbnailfile')).withMessage(
+      'This thumbnail file is not supported or too large. Please, make sure it is of the following type: '
+      + CONSTRAINTS_FIELDS.VIDEO_PLAYLISTS.IMAGE.EXTNAME.join(', ')
+    ),
+
+    body('displayName')
+      .custom(isVideoPlaylistNameValid).withMessage('Should have a valid display name'),
+    body('description')
+      .optional()
+      .customSanitizer(toValueOrNull)
+      .custom(isVideoPlaylistDescriptionValid).withMessage('Should have a valid description'),
+    body('privacy')
+      .optional()
+      .toInt()
+      .custom(isVideoPlaylistPrivacyValid).withMessage('Should have correct playlist privacy'),
+    body('videoChannelId')
+      .optional()
+      .customSanitizer(toValueOrNull)
+      .toInt()
+  ] as (ValidationChain | express.Handler)[]
+}
+
+function checkUserCanManageVideoPlaylist (user: UserModel, videoPlaylist: VideoPlaylistModel, right: UserRight, res: express.Response) {
+  if (videoPlaylist.isOwned() === false) {
+    res.status(403)
+       .json({ error: 'Cannot manage video playlist of another server.' })
+       .end()
+
+    return false
+  }
+
+  // Check if the user can manage the video playlist
+  // The user can delete it if s/he is an admin
+  // Or if s/he is the video playlist's owner
+  if (user.hasRight(right) === false && videoPlaylist.ownerAccountId !== user.Account.id) {
+    res.status(403)
+       .json({ error: 'Cannot manage video playlist of another user' })
+       .end()
+
+    return false
+  }
+
+  return true
+}
diff --git a/server/middlewares/validators/videos/video-rates.ts b/server/middlewares/validators/videos/video-rates.ts
index 793354520..204b4a78d 100644
--- a/server/middlewares/validators/videos/video-rates.ts
+++ b/server/middlewares/validators/videos/video-rates.ts
@@ -1,8 +1,9 @@
 import * as express from 'express'
 import 'express-validator'
-import { body, param } from 'express-validator/check'
-import { isIdOrUUIDValid, isIdValid } from '../../../helpers/custom-validators/misc'
-import { isVideoExist, isVideoRatingTypeValid } from '../../../helpers/custom-validators/videos'
+import { body, param, query } from 'express-validator/check'
+import { isIdOrUUIDValid } from '../../../helpers/custom-validators/misc'
+import { isRatingValid } from '../../../helpers/custom-validators/video-rates'
+import { doesVideoExist, isVideoRatingTypeValid } from '../../../helpers/custom-validators/videos'
 import { logger } from '../../../helpers/logger'
 import { areValidationErrors } from '../utils'
 import { AccountVideoRateModel } from '../../../models/account/account-video-rate'
@@ -17,7 +18,7 @@ const videoUpdateRateValidator = [
     logger.debug('Checking videoRate parameters', { parameters: req.body })
 
     if (areValidationErrors(req, res)) return
-    if (!await isVideoExist(req.params.id, res)) return
+    if (!await doesVideoExist(req.params.id, res)) return
 
     return next()
   }
@@ -47,9 +48,22 @@ const getAccountVideoRateValidator = function (rateType: VideoRateType) {
   ]
 }
 
+const videoRatingValidator = [
+  query('rating').optional().custom(isRatingValid).withMessage('Value must be one of "like" or "dislike"'),
+
+  async (req: express.Request, res: express.Response, next: express.NextFunction) => {
+    logger.debug('Checking rating parameter', { parameters: req.params })
+
+    if (areValidationErrors(req, res)) return
+
+    return next()
+  }
+]
+
 // ---------------------------------------------------------------------------
 
 export {
   videoUpdateRateValidator,
-  getAccountVideoRateValidator
+  getAccountVideoRateValidator,
+  videoRatingValidator
 }
diff --git a/server/middlewares/validators/videos/video-shares.ts b/server/middlewares/validators/videos/video-shares.ts
index 646d7acb1..d5cbdb03e 100644
--- a/server/middlewares/validators/videos/video-shares.ts
+++ b/server/middlewares/validators/videos/video-shares.ts
@@ -2,11 +2,10 @@ import * as express from 'express'
 import 'express-validator'
 import { param } from 'express-validator/check'
 import { isIdOrUUIDValid, isIdValid } from '../../../helpers/custom-validators/misc'
-import { isVideoExist } from '../../../helpers/custom-validators/videos'
+import { doesVideoExist } from '../../../helpers/custom-validators/videos'
 import { logger } from '../../../helpers/logger'
 import { VideoShareModel } from '../../../models/video/video-share'
 import { areValidationErrors } from '../utils'
-import { VideoModel } from '../../../models/video/video'
 
 const videosShareValidator = [
   param('id').custom(isIdOrUUIDValid).not().isEmpty().withMessage('Should have a valid id'),
@@ -16,9 +15,9 @@ const videosShareValidator = [
     logger.debug('Checking videoShare parameters', { parameters: req.params })
 
     if (areValidationErrors(req, res)) return
-    if (!await isVideoExist(req.params.id, res)) return
+    if (!await doesVideoExist(req.params.id, res)) return
 
-    const video: VideoModel = res.locals.video
+    const video = res.locals.video
 
     const share = await VideoShareModel.load(req.params.actorId, video.id)
     if (!share) {
diff --git a/server/middlewares/validators/videos/video-watch.ts b/server/middlewares/validators/videos/video-watch.ts
index c38ad8a10..a3a800d14 100644
--- a/server/middlewares/validators/videos/video-watch.ts
+++ b/server/middlewares/validators/videos/video-watch.ts
@@ -1,10 +1,9 @@
 import { body, param } from 'express-validator/check'
 import * as express from 'express'
 import { isIdOrUUIDValid } from '../../../helpers/custom-validators/misc'
-import { isVideoExist } from '../../../helpers/custom-validators/videos'
+import { doesVideoExist } from '../../../helpers/custom-validators/videos'
 import { areValidationErrors } from '../utils'
 import { logger } from '../../../helpers/logger'
-import { UserModel } from '../../../models/account/user'
 
 const videoWatchingValidator = [
   param('videoId').custom(isIdOrUUIDValid).not().isEmpty().withMessage('Should have a valid id'),
@@ -16,9 +15,9 @@ const videoWatchingValidator = [
     logger.debug('Checking videoWatching parameters', { parameters: req.body })
 
     if (areValidationErrors(req, res)) return
-    if (!await isVideoExist(req.params.videoId, res, 'id')) return
+    if (!await doesVideoExist(req.params.videoId, res, 'id')) return
 
-    const user = res.locals.oauth.token.User as UserModel
+    const user = res.locals.oauth.token.User
     if (user.videosHistoryEnabled === false) {
       logger.warn('Cannot set videos to watch by user %d: videos history is disabled.', user.id)
       return res.status(409).end()
diff --git a/server/middlewares/validators/videos/videos.ts b/server/middlewares/validators/videos/videos.ts
index 051a19e16..2b01f108d 100644
--- a/server/middlewares/validators/videos/videos.ts
+++ b/server/middlewares/validators/videos/videos.ts
@@ -14,38 +14,38 @@ import {
 } from '../../../helpers/custom-validators/misc'
 import {
   checkUserCanManageVideo,
+  doesVideoChannelOfAccountExist,
+  doesVideoExist,
   isScheduleVideoUpdatePrivacyValid,
   isVideoCategoryValid,
-  isVideoChannelOfAccountExist,
   isVideoDescriptionValid,
-  isVideoExist,
   isVideoFile,
   isVideoFilterValid,
   isVideoImage,
   isVideoLanguageValid,
   isVideoLicenceValid,
   isVideoNameValid,
+  isVideoOriginallyPublishedAtValid,
   isVideoPrivacyValid,
   isVideoSupportValid,
   isVideoTagsValid
 } from '../../../helpers/custom-validators/videos'
 import { getDurationFromVideoFile } from '../../../helpers/ffmpeg-utils'
 import { logger } from '../../../helpers/logger'
-import { CONFIG, CONSTRAINTS_FIELDS } from '../../../initializers'
+import { CONSTRAINTS_FIELDS } from '../../../initializers/constants'
 import { authenticatePromiseIfNeeded } from '../../oauth'
 import { areValidationErrors } from '../utils'
 import { cleanUpReqFiles } from '../../../helpers/express-utils'
 import { VideoModel } from '../../../models/video/video'
-import { UserModel } from '../../../models/account/user'
 import { checkUserCanTerminateOwnershipChange, doesChangeVideoOwnershipExist } from '../../../helpers/custom-validators/video-ownership'
 import { VideoChangeOwnershipAccept } from '../../../../shared/models/videos/video-change-ownership-accept.model'
-import { VideoChangeOwnershipModel } from '../../../models/video/video-change-ownership'
 import { AccountModel } from '../../../models/account/account'
 import { VideoFetchType } from '../../../helpers/video'
 import { isNSFWQueryValid, isNumberArray, isStringArray } from '../../../helpers/custom-validators/search'
 import { getServerActor } from '../../../helpers/utils'
+import { CONFIG } from '../../../initializers/config'
 
-const videosAddValidator = getCommonVideoAttributes().concat([
+const videosAddValidator = getCommonVideoEditAttributes().concat([
   body('videofile')
     .custom((value, { req }) => isVideoFile(req.files)).withMessage(
       'This file is not supported or too large. Please, make sure it is of the following type: '
@@ -65,9 +65,10 @@ const videosAddValidator = getCommonVideoAttributes().concat([
     const videoFile: Express.Multer.File = req.files['videofile'][0]
     const user = res.locals.oauth.token.User
 
-    if (!await isVideoChannelOfAccountExist(req.body.channelId, user, res)) return cleanUpReqFiles(req)
+    if (!await doesVideoChannelOfAccountExist(req.body.channelId, user, res)) return cleanUpReqFiles(req)
 
     const isAble = await user.isAbleToUploadVideo(videoFile)
+
     if (isAble === false) {
       res.status(403)
          .json({ error: 'The user video quota is exceeded with this video.' })
@@ -93,7 +94,7 @@ const videosAddValidator = getCommonVideoAttributes().concat([
   }
 ])
 
-const videosUpdateValidator = getCommonVideoAttributes().concat([
+const videosUpdateValidator = getCommonVideoEditAttributes().concat([
   param('id').custom(isIdOrUUIDValid).not().isEmpty().withMessage('Should have a valid id'),
   body('name')
     .optional()
@@ -108,7 +109,7 @@ const videosUpdateValidator = getCommonVideoAttributes().concat([
 
     if (areValidationErrors(req, res)) return cleanUpReqFiles(req)
     if (areErrorsInScheduleUpdate(req, res)) return cleanUpReqFiles(req)
-    if (!await isVideoExist(req.params.id, res)) return cleanUpReqFiles(req)
+    if (!await doesVideoExist(req.params.id, res)) return cleanUpReqFiles(req)
 
     const video = res.locals.video
 
@@ -122,14 +123,14 @@ const videosUpdateValidator = getCommonVideoAttributes().concat([
         .json({ error: 'Cannot set "private" a video that was not private.' })
     }
 
-    if (req.body.channelId && !await isVideoChannelOfAccountExist(req.body.channelId, user, res)) return cleanUpReqFiles(req)
+    if (req.body.channelId && !await doesVideoChannelOfAccountExist(req.body.channelId, user, res)) return cleanUpReqFiles(req)
 
     return next()
   }
 ])
 
 async function checkVideoFollowConstraints (req: express.Request, res: express.Response, next: express.NextFunction) {
-  const video: VideoModel = res.locals.video
+  const video = res.locals.video
 
   // Anybody can watch local videos
   if (video.isOwned() === true) return next()
@@ -161,15 +162,15 @@ const videosCustomGetValidator = (fetchType: VideoFetchType) => {
       logger.debug('Checking videosGet parameters', { parameters: req.params })
 
       if (areValidationErrors(req, res)) return
-      if (!await isVideoExist(req.params.id, res, fetchType)) return
+      if (!await doesVideoExist(req.params.id, res, fetchType)) return
 
-      const video: VideoModel = res.locals.video
+      const video = res.locals.video
 
       // Video private or blacklisted
       if (video.privacy === VideoPrivacy.PRIVATE || video.VideoBlacklist) {
         await authenticatePromiseIfNeeded(req, res)
 
-        const user: UserModel = res.locals.oauth ? res.locals.oauth.token.User : null
+        const user = res.locals.oauth ? res.locals.oauth.token.User : null
 
         // Only the owner or a user that have blacklist rights can see the video
         if (
@@ -206,7 +207,7 @@ const videosRemoveValidator = [
     logger.debug('Checking videosRemove parameters', { parameters: req.params })
 
     if (areValidationErrors(req, res)) return
-    if (!await isVideoExist(req.params.id, res)) return
+    if (!await doesVideoExist(req.params.id, res)) return
 
     // Check if the user who did the request is able to delete the video
     if (!checkUserCanManageVideo(res.locals.oauth.token.User, res.locals.video, UserRight.REMOVE_ANY_VIDEO, res)) return
@@ -222,7 +223,7 @@ const videosChangeOwnershipValidator = [
     logger.debug('Checking changeOwnership parameters', { parameters: req.params })
 
     if (areValidationErrors(req, res)) return
-    if (!await isVideoExist(req.params.videoId, res)) return
+    if (!await doesVideoExist(req.params.videoId, res)) return
 
     // Check if the user who did the request is able to change the ownership of the video
     if (!checkUserCanManageVideo(res.locals.oauth.token.User, res.locals.video, UserRight.CHANGE_VIDEO_OWNERSHIP, res)) return
@@ -255,7 +256,7 @@ const videosTerminateChangeOwnershipValidator = [
     return next()
   },
   async (req: express.Request, res: express.Response, next: express.NextFunction) => {
-    const videoChangeOwnership = res.locals.videoChangeOwnership as VideoChangeOwnershipModel
+    const videoChangeOwnership = res.locals.videoChangeOwnership
 
     if (videoChangeOwnership.status === VideoChangeOwnershipStatus.WAITING) {
       return next()
@@ -271,10 +272,10 @@ const videosTerminateChangeOwnershipValidator = [
 const videosAcceptChangeOwnershipValidator = [
   async (req: express.Request, res: express.Response, next: express.NextFunction) => {
     const body = req.body as VideoChangeOwnershipAccept
-    if (!await isVideoChannelOfAccountExist(body.channelId, res.locals.oauth.token.User, res)) return
+    if (!await doesVideoChannelOfAccountExist(body.channelId, res.locals.oauth.token.User, res)) return
 
     const user = res.locals.oauth.token.User
-    const videoChangeOwnership = res.locals.videoChangeOwnership as VideoChangeOwnershipModel
+    const videoChangeOwnership = res.locals.videoChangeOwnership
     const isAble = await user.isAbleToUploadVideo(videoChangeOwnership.Video.getOriginalFile())
     if (isAble === false) {
       res.status(403)
@@ -287,7 +288,7 @@ const videosAcceptChangeOwnershipValidator = [
   }
 ]
 
-function getCommonVideoAttributes () {
+function getCommonVideoEditAttributes () {
   return [
     body('thumbnailfile')
       .custom((value, { req }) => isVideoImage(req.files, 'thumbnailfile')).withMessage(
@@ -340,7 +341,14 @@ function getCommonVideoAttributes () {
       .optional()
       .toBoolean()
       .custom(isBooleanValid).withMessage('Should have comments enabled boolean'),
-
+    body('downloadEnabled')
+      .optional()
+      .toBoolean()
+      .custom(isBooleanValid).withMessage('Should have downloading enabled boolean'),
+    body('originallyPublishedAt')
+        .optional()
+        .customSanitizer(toValueOrNull)
+        .custom(isVideoOriginallyPublishedAtValid).withMessage('Should have a valid original publication date'),
     body('scheduleUpdate')
       .optional()
       .customSanitizer(toValueOrNull),
@@ -387,7 +395,7 @@ const commonVideosFiltersValidator = [
 
     if (areValidationErrors(req, res)) return
 
-    const user: UserModel = res.locals.oauth ? res.locals.oauth.token.User : undefined
+    const user = res.locals.oauth ? res.locals.oauth.token.User : undefined
     if (req.query.filter === 'all-local' && (!user || user.hasRight(UserRight.SEE_ALL_VIDEOS) === false)) {
       res.status(401)
          .json({ error: 'You are not allowed to see all local videos.' })
@@ -413,7 +421,7 @@ export {
   videosTerminateChangeOwnershipValidator,
   videosAcceptChangeOwnershipValidator,
 
-  getCommonVideoAttributes,
+  getCommonVideoEditAttributes,
 
   commonVideosFiltersValidator
 }
diff --git a/server/models/account/account-blocklist.ts b/server/models/account/account-blocklist.ts
index efd6ed59e..d5746ad76 100644
--- a/server/models/account/account-blocklist.ts
+++ b/server/models/account/account-blocklist.ts
@@ -8,22 +8,22 @@ enum ScopeNames {
   WITH_ACCOUNTS = 'WITH_ACCOUNTS'
 }
 
-@Scopes({
+@Scopes(() => ({
   [ScopeNames.WITH_ACCOUNTS]: {
     include: [
       {
-        model: () => AccountModel,
+        model: AccountModel,
         required: true,
         as: 'ByAccount'
       },
       {
-        model: () => AccountModel,
+        model: AccountModel,
         required: true,
         as: 'BlockedAccount'
       }
     ]
   }
-})
+}))
 
 @Table({
   tableName: 'accountBlocklist',
@@ -83,7 +83,7 @@ export class AccountBlocklistModel extends Model<AccountBlocklistModel> {
       attributes: [ 'accountId', 'id' ],
       where: {
         accountId: {
-          [Op.any]: accountIds
+          [Op.in]: accountIds // FIXME: sequelize ANY seems broken
         },
         targetAccountId
       },
diff --git a/server/models/account/account-video-rate.ts b/server/models/account/account-video-rate.ts
index 18762f0c5..59f586b54 100644
--- a/server/models/account/account-video-rate.ts
+++ b/server/models/account/account-video-rate.ts
@@ -1,14 +1,15 @@
 import { values } from 'lodash'
-import { Transaction } from 'sequelize'
+import { FindOptions, Op, Transaction } from 'sequelize'
 import { AllowNull, BelongsTo, Column, CreatedAt, DataType, ForeignKey, Is, Model, Table, UpdatedAt } from 'sequelize-typescript'
-import { IFindOptions } from 'sequelize-typescript/lib/interfaces/IFindOptions'
 import { VideoRateType } from '../../../shared/models/videos'
-import { CONSTRAINTS_FIELDS, VIDEO_RATE_TYPES } from '../../initializers'
+import { CONSTRAINTS_FIELDS, VIDEO_RATE_TYPES } from '../../initializers/constants'
 import { VideoModel } from '../video/video'
 import { AccountModel } from './account'
 import { ActorModel } from '../activitypub/actor'
-import { throwIfNotValid } from '../utils'
+import { getSort, throwIfNotValid } from '../utils'
 import { isActivityPubUrlValid } from '../../helpers/custom-validators/activitypub/misc'
+import { AccountVideoRate } from '../../../shared'
+import { ScopeNames as VideoChannelScopeNames, VideoChannelModel } from '../video/video-channel'
 
 /*
   Account rates per video.
@@ -38,7 +39,7 @@ import { isActivityPubUrlValid } from '../../helpers/custom-validators/activityp
 export class AccountVideoRateModel extends Model<AccountVideoRateModel> {
 
   @AllowNull(false)
-  @Column(DataType.ENUM(values(VIDEO_RATE_TYPES)))
+  @Column(DataType.ENUM(...values(VIDEO_RATE_TYPES)))
   type: VideoRateType
 
   @AllowNull(false)
@@ -77,7 +78,7 @@ export class AccountVideoRateModel extends Model<AccountVideoRateModel> {
   Account: AccountModel
 
   static load (accountId: number, videoId: number, transaction?: Transaction) {
-    const options: IFindOptions<AccountVideoRateModel> = {
+    const options: FindOptions = {
       where: {
         accountId,
         videoId
@@ -88,8 +89,40 @@ export class AccountVideoRateModel extends Model<AccountVideoRateModel> {
     return AccountVideoRateModel.findOne(options)
   }
 
+  static listByAccountForApi (options: {
+    start: number,
+    count: number,
+    sort: string,
+    type?: string,
+    accountId: number
+  }) {
+    const query: FindOptions = {
+      offset: options.start,
+      limit: options.count,
+      order: getSort(options.sort),
+      where: {
+        accountId: options.accountId
+      },
+      include: [
+        {
+          model: VideoModel,
+          required: true,
+          include: [
+            {
+              model: VideoChannelModel.scope({ method: [VideoChannelScopeNames.SUMMARY, true] }),
+              required: true
+            }
+          ]
+        }
+      ]
+    }
+    if (options.type) query.where['type'] = options.type
+
+    return AccountVideoRateModel.findAndCountAll(query)
+  }
+
   static loadLocalAndPopulateVideo (rateType: VideoRateType, accountName: string, videoId: number, transaction?: Transaction) {
-    const options: IFindOptions<AccountVideoRateModel> = {
+    const options: FindOptions = {
       where: {
         videoId,
         type: rateType
@@ -121,7 +154,7 @@ export class AccountVideoRateModel extends Model<AccountVideoRateModel> {
   }
 
   static loadByUrl (url: string, transaction: Transaction) {
-    const options: IFindOptions<AccountVideoRateModel> = {
+    const options: FindOptions = {
       where: {
         url
       }
@@ -158,4 +191,38 @@ export class AccountVideoRateModel extends Model<AccountVideoRateModel> {
 
     return AccountVideoRateModel.findAndCountAll(query)
   }
+
+  static cleanOldRatesOf (videoId: number, type: VideoRateType, beforeUpdatedAt: Date) {
+    return AccountVideoRateModel.sequelize.transaction(async t => {
+      const query = {
+        where: {
+          updatedAt: {
+            [Op.lt]: beforeUpdatedAt
+          },
+          videoId,
+          type
+        },
+        transaction: t
+      }
+
+      const deleted = await AccountVideoRateModel.destroy(query)
+
+      const options = {
+        transaction: t,
+        where: {
+          id: videoId
+        }
+      }
+
+      if (type === 'like') await VideoModel.increment({ likes: -deleted }, options)
+      else if (type === 'dislike') await VideoModel.increment({ dislikes: -deleted }, options)
+    })
+  }
+
+  toFormattedJSON (): AccountVideoRate {
+    return {
+      video: this.Video.toFormattedJSON(),
+      rating: this.type
+    }
+  }
 }
diff --git a/server/models/account/account.ts b/server/models/account/account.ts
index 84ef0b30d..2b04acd86 100644
--- a/server/models/account/account.ts
+++ b/server/models/account/account.ts
@@ -1,20 +1,20 @@
-import * as Sequelize from 'sequelize'
 import {
   AllowNull,
   BeforeDestroy,
   BelongsTo,
   Column,
-  CreatedAt,
+  CreatedAt, DataType,
   Default,
   DefaultScope,
   ForeignKey,
   HasMany,
   Is,
   Model,
+  Scopes,
   Table,
   UpdatedAt
 } from 'sequelize-typescript'
-import { Account } from '../../../shared/models/actors'
+import { Account, AccountSummary } from '../../../shared/models/actors'
 import { isAccountDescriptionValid } from '../../helpers/custom-validators/accounts'
 import { sendDeleteActor } from '../../lib/activitypub/send'
 import { ActorModel } from '../activitypub/actor'
@@ -24,15 +24,49 @@ import { getSort, throwIfNotValid } from '../utils'
 import { VideoChannelModel } from '../video/video-channel'
 import { VideoCommentModel } from '../video/video-comment'
 import { UserModel } from './user'
+import { AvatarModel } from '../avatar/avatar'
+import { VideoPlaylistModel } from '../video/video-playlist'
+import { CONSTRAINTS_FIELDS, WEBSERVER } from '../../initializers/constants'
+import { Op, Transaction, WhereOptions } from 'sequelize'
 
-@DefaultScope({
+export enum ScopeNames {
+  SUMMARY = 'SUMMARY'
+}
+
+@DefaultScope(() => ({
   include: [
     {
-      model: () => ActorModel, // Default scope includes avatar and server
+      model: ActorModel, // Default scope includes avatar and server
       required: true
     }
   ]
-})
+}))
+@Scopes(() => ({
+  [ ScopeNames.SUMMARY ]: (whereActor?: WhereOptions) => {
+    return {
+      attributes: [ 'id', 'name' ],
+      include: [
+        {
+          attributes: [ 'id', 'uuid', 'preferredUsername', 'url', 'serverId', 'avatarId' ],
+          model: ActorModel.unscoped(),
+          required: true,
+          where: whereActor,
+          include: [
+            {
+              attributes: [ 'host' ],
+              model: ServerModel.unscoped(),
+              required: false
+            },
+            {
+              model: AvatarModel.unscoped(),
+              required: false
+            }
+          ]
+        }
+      ]
+    }
+  }
+}))
 @Table({
   tableName: 'account',
   indexes: [
@@ -56,8 +90,8 @@ export class AccountModel extends Model<AccountModel> {
 
   @AllowNull(true)
   @Default(null)
-  @Is('AccountDescription', value => throwIfNotValid(value, isAccountDescriptionValid, 'description'))
-  @Column
+  @Is('AccountDescription', value => throwIfNotValid(value, isAccountDescriptionValid, 'description', true))
+  @Column(DataType.STRING(CONSTRAINTS_FIELDS.USERS.DESCRIPTION.max))
   description: string
 
   @CreatedAt
@@ -111,6 +145,15 @@ export class AccountModel extends Model<AccountModel> {
   })
   VideoChannels: VideoChannelModel[]
 
+  @HasMany(() => VideoPlaylistModel, {
+    foreignKey: {
+      allowNull: false
+    },
+    onDelete: 'cascade',
+    hooks: true
+  })
+  VideoPlaylists: VideoPlaylistModel[]
+
   @HasMany(() => VideoCommentModel, {
     foreignKey: {
       allowNull: false
@@ -133,8 +176,8 @@ export class AccountModel extends Model<AccountModel> {
     return undefined
   }
 
-  static load (id: number, transaction?: Sequelize.Transaction) {
-    return AccountModel.findById(id, { transaction })
+  static load (id: number, transaction?: Transaction) {
+    return AccountModel.findByPk(id, { transaction })
   }
 
   static loadByUUID (uuid: string) {
@@ -153,18 +196,26 @@ export class AccountModel extends Model<AccountModel> {
     return AccountModel.findOne(query)
   }
 
+  static loadByNameWithHost (nameWithHost: string) {
+    const [ accountName, host ] = nameWithHost.split('@')
+
+    if (!host || host === WEBSERVER.HOST) return AccountModel.loadLocalByName(accountName)
+
+    return AccountModel.loadByNameAndHost(accountName, host)
+  }
+
   static loadLocalByName (name: string) {
     const query = {
       where: {
-        [ Sequelize.Op.or ]: [
+        [ Op.or ]: [
           {
             userId: {
-              [ Sequelize.Op.ne ]: null
+              [ Op.ne ]: null
             }
           },
           {
             applicationId: {
-              [ Sequelize.Op.ne ]: null
+              [ Op.ne ]: null
             }
           }
         ]
@@ -208,7 +259,7 @@ export class AccountModel extends Model<AccountModel> {
     return AccountModel.findOne(query)
   }
 
-  static loadByUrl (url: string, transaction?: Sequelize.Transaction) {
+  static loadByUrl (url: string, transaction?: Transaction) {
     const query = {
       include: [
         {
@@ -276,6 +327,20 @@ export class AccountModel extends Model<AccountModel> {
     return Object.assign(actor, account)
   }
 
+  toFormattedSummaryJSON (): AccountSummary {
+    const actor = this.Actor.toFormattedJSON()
+
+    return {
+      id: this.id,
+      uuid: actor.uuid,
+      name: actor.name,
+      displayName: this.getDisplayName(),
+      url: actor.url,
+      host: actor.host,
+      avatar: actor.avatar
+    }
+  }
+
   toActivityPubObject () {
     const obj = this.Actor.toActivityPubObject(this.name, 'Account')
 
diff --git a/server/models/account/user-notification-setting.ts b/server/models/account/user-notification-setting.ts
index f1c3ac223..c2fbc6d23 100644
--- a/server/models/account/user-notification-setting.ts
+++ b/server/models/account/user-notification-setting.ts
@@ -59,6 +59,15 @@ export class UserNotificationSettingModel extends Model<UserNotificationSettingM
   @AllowNull(false)
   @Default(null)
   @Is(
+    'UserNotificationSettingVideoAutoBlacklistAsModerator',
+    value => throwIfNotValid(value, isUserNotificationSettingValid, 'videoAutoBlacklistAsModerator')
+  )
+  @Column
+  videoAutoBlacklistAsModerator: UserNotificationSettingValue
+
+  @AllowNull(false)
+  @Default(null)
+  @Is(
     'UserNotificationSettingBlacklistOnMyVideo',
     value => throwIfNotValid(value, isUserNotificationSettingValid, 'blacklistOnMyVideo')
   )
@@ -95,6 +104,15 @@ export class UserNotificationSettingModel extends Model<UserNotificationSettingM
   @AllowNull(false)
   @Default(null)
   @Is(
+    'UserNotificationSettingNewInstanceFollower',
+    value => throwIfNotValid(value, isUserNotificationSettingValid, 'newInstanceFollower')
+  )
+  @Column
+  newInstanceFollower: UserNotificationSettingValue
+
+  @AllowNull(false)
+  @Default(null)
+  @Is(
     'UserNotificationSettingNewFollow',
     value => throwIfNotValid(value, isUserNotificationSettingValid, 'newFollow')
   )
@@ -139,12 +157,14 @@ export class UserNotificationSettingModel extends Model<UserNotificationSettingM
       newCommentOnMyVideo: this.newCommentOnMyVideo,
       newVideoFromSubscription: this.newVideoFromSubscription,
       videoAbuseAsModerator: this.videoAbuseAsModerator,
+      videoAutoBlacklistAsModerator: this.videoAutoBlacklistAsModerator,
       blacklistOnMyVideo: this.blacklistOnMyVideo,
       myVideoPublished: this.myVideoPublished,
       myVideoImportFinished: this.myVideoImportFinished,
       newUserRegistration: this.newUserRegistration,
       commentMention: this.commentMention,
-      newFollow: this.newFollow
+      newFollow: this.newFollow,
+      newInstanceFollower: this.newInstanceFollower
     }
   }
 }
diff --git a/server/models/account/user-notification.ts b/server/models/account/user-notification.ts
index 6cdbb827b..a4f97037b 100644
--- a/server/models/account/user-notification.ts
+++ b/server/models/account/user-notification.ts
@@ -1,17 +1,4 @@
-import {
-  AllowNull,
-  BelongsTo,
-  Column,
-  CreatedAt,
-  Default,
-  ForeignKey,
-  IFindOptions,
-  Is,
-  Model,
-  Scopes,
-  Table,
-  UpdatedAt
-} from 'sequelize-typescript'
+import { AllowNull, BelongsTo, Column, CreatedAt, Default, ForeignKey, Is, Model, Scopes, Table, UpdatedAt } from 'sequelize-typescript'
 import { UserNotification, UserNotificationType } from '../../../shared'
 import { getSort, throwIfNotValid } from '../utils'
 import { isBooleanValid } from '../../helpers/custom-validators/misc'
@@ -19,7 +6,7 @@ import { isUserNotificationTypeValid } from '../../helpers/custom-validators/use
 import { UserModel } from './user'
 import { VideoModel } from '../video/video'
 import { VideoCommentModel } from '../video/video-comment'
-import { Op } from 'sequelize'
+import { FindOptions, ModelIndexesOptions, Op, WhereOptions } from 'sequelize'
 import { VideoChannelModel } from '../video/video-channel'
 import { AccountModel } from './account'
 import { VideoAbuseModel } from '../video/video-abuse'
@@ -37,17 +24,17 @@ enum ScopeNames {
 function buildActorWithAvatarInclude () {
   return {
     attributes: [ 'preferredUsername' ],
-    model: () => ActorModel.unscoped(),
+    model: ActorModel.unscoped(),
     required: true,
     include: [
       {
         attributes: [ 'filename' ],
-        model: () => AvatarModel.unscoped(),
+        model: AvatarModel.unscoped(),
         required: false
       },
       {
         attributes: [ 'host' ],
-        model: () => ServerModel.unscoped(),
+        model: ServerModel.unscoped(),
         required: false
       }
     ]
@@ -57,7 +44,7 @@ function buildActorWithAvatarInclude () {
 function buildVideoInclude (required: boolean) {
   return {
     attributes: [ 'id', 'uuid', 'name' ],
-    model: () => VideoModel.unscoped(),
+    model: VideoModel.unscoped(),
     required
   }
 }
@@ -66,7 +53,7 @@ function buildChannelInclude (required: boolean, withActor = false) {
   return {
     required,
     attributes: [ 'id', 'name' ],
-    model: () => VideoChannelModel.unscoped(),
+    model: VideoChannelModel.unscoped(),
     include: withActor === true ? [ buildActorWithAvatarInclude() ] : []
   }
 }
@@ -75,12 +62,12 @@ function buildAccountInclude (required: boolean, withActor = false) {
   return {
     required,
     attributes: [ 'id', 'name' ],
-    model: () => AccountModel.unscoped(),
+    model: AccountModel.unscoped(),
     include: withActor === true ? [ buildActorWithAvatarInclude() ] : []
   }
 }
 
-@Scopes({
+@Scopes(() => ({
   [ScopeNames.WITH_ALL]: {
     include: [
       Object.assign(buildVideoInclude(false), {
@@ -89,7 +76,7 @@ function buildAccountInclude (required: boolean, withActor = false) {
 
       {
         attributes: [ 'id', 'originCommentId' ],
-        model: () => VideoCommentModel.unscoped(),
+        model: VideoCommentModel.unscoped(),
         required: false,
         include: [
           buildAccountInclude(true, true),
@@ -99,56 +86,56 @@ function buildAccountInclude (required: boolean, withActor = false) {
 
       {
         attributes: [ 'id' ],
-        model: () => VideoAbuseModel.unscoped(),
+        model: VideoAbuseModel.unscoped(),
         required: false,
         include: [ buildVideoInclude(true) ]
       },
 
       {
         attributes: [ 'id' ],
-        model: () => VideoBlacklistModel.unscoped(),
+        model: VideoBlacklistModel.unscoped(),
         required: false,
         include: [ buildVideoInclude(true) ]
       },
 
       {
         attributes: [ 'id', 'magnetUri', 'targetUrl', 'torrentName' ],
-        model: () => VideoImportModel.unscoped(),
+        model: VideoImportModel.unscoped(),
         required: false,
         include: [ buildVideoInclude(false) ]
       },
 
       {
-        attributes: [ 'id' ],
-        model: () => ActorFollowModel.unscoped(),
+        attributes: [ 'id', 'state' ],
+        model: ActorFollowModel.unscoped(),
         required: false,
         include: [
           {
             attributes: [ 'preferredUsername' ],
-            model: () => ActorModel.unscoped(),
+            model: ActorModel.unscoped(),
             required: true,
             as: 'ActorFollower',
             include: [
               {
                 attributes: [ 'id', 'name' ],
-                model: () => AccountModel.unscoped(),
+                model: AccountModel.unscoped(),
                 required: true
               },
               {
                 attributes: [ 'filename' ],
-                model: () => AvatarModel.unscoped(),
+                model: AvatarModel.unscoped(),
                 required: false
               },
               {
                 attributes: [ 'host' ],
-                model: () => ServerModel.unscoped(),
+                model: ServerModel.unscoped(),
                 required: false
               }
             ]
           },
           {
             attributes: [ 'preferredUsername' ],
-            model: () => ActorModel.unscoped(),
+            model: ActorModel.unscoped(),
             required: true,
             as: 'ActorFollowing',
             include: [
@@ -162,7 +149,7 @@ function buildAccountInclude (required: boolean, withActor = false) {
       buildAccountInclude(false, true)
     ]
   }
-})
+}))
 @Table({
   tableName: 'userNotification',
   indexes: [
@@ -225,7 +212,7 @@ function buildAccountInclude (required: boolean, withActor = false) {
         }
       }
     }
-  ]
+  ] as (ModelIndexesOptions & { where?: WhereOptions })[]
 })
 export class UserNotificationModel extends Model<UserNotificationModel> {
 
@@ -344,7 +331,7 @@ export class UserNotificationModel extends Model<UserNotificationModel> {
   ActorFollow: ActorFollowModel
 
   static listForApi (userId: number, start: number, count: number, sort: string, unread?: boolean) {
-    const query: IFindOptions<UserNotificationModel> = {
+    const query: FindOptions = {
       offset: start,
       limit: count,
       order: getSort(sort),
@@ -370,7 +357,7 @@ export class UserNotificationModel extends Model<UserNotificationModel> {
       where: {
         userId,
         id: {
-          [Op.any]: notificationIds
+          [Op.in]: notificationIds // FIXME: sequelize ANY seems broken
         }
       }
     }
@@ -418,6 +405,7 @@ export class UserNotificationModel extends Model<UserNotificationModel> {
 
     const actorFollow = this.ActorFollow ? {
       id: this.ActorFollow.id,
+      state: this.ActorFollow.state,
       follower: {
         id: this.ActorFollow.ActorFollower.Account.id,
         displayName: this.ActorFollow.ActorFollower.Account.getDisplayName(),
diff --git a/server/models/account/user-video-history.ts b/server/models/account/user-video-history.ts
index 15cb399c9..a862fc45f 100644
--- a/server/models/account/user-video-history.ts
+++ b/server/models/account/user-video-history.ts
@@ -67,7 +67,7 @@ export class UserVideoHistoryModel extends Model<UserVideoHistoryModel> {
     })
   }
 
-  static removeHistoryBefore (user: UserModel, beforeDate: string, t: Transaction) {
+  static removeUserHistoryBefore (user: UserModel, beforeDate: string, t: Transaction) {
     const query: DestroyOptions = {
       where: {
         userId: user.id
@@ -76,11 +76,23 @@ export class UserVideoHistoryModel extends Model<UserVideoHistoryModel> {
     }
 
     if (beforeDate) {
-      query.where.updatedAt = {
+      query.where['updatedAt'] = {
         [Op.lt]: beforeDate
       }
     }
 
     return UserVideoHistoryModel.destroy(query)
   }
+
+  static removeOldHistory (beforeDate: string) {
+    const query: DestroyOptions = {
+      where: {
+        updatedAt: {
+          [Op.lt]: beforeDate
+        }
+      }
+    }
+
+    return UserVideoHistoryModel.destroy(query)
+  }
 }
diff --git a/server/models/account/user.ts b/server/models/account/user.ts
index 017a96657..4a9acd703 100644
--- a/server/models/account/user.ts
+++ b/server/models/account/user.ts
@@ -1,4 +1,4 @@
-import * as Sequelize from 'sequelize'
+import { FindOptions, literal, Op, QueryTypes } from 'sequelize'
 import {
   AfterDestroy,
   AfterUpdate,
@@ -22,6 +22,7 @@ import {
 import { hasUserRight, USER_ROLE_LABELS, UserRight } from '../../../shared'
 import { User, UserRole } from '../../../shared/models/users'
 import {
+  isUserAdminFlagsValid,
   isUserAutoPlayVideoValid,
   isUserBlockedReasonValid,
   isUserBlockedValid,
@@ -42,45 +43,46 @@ import { VideoChannelModel } from '../video/video-channel'
 import { AccountModel } from './account'
 import { NSFWPolicyType } from '../../../shared/models/videos/nsfw-policy.type'
 import { values } from 'lodash'
-import { NSFW_POLICY_TYPES } from '../../initializers'
+import { NSFW_POLICY_TYPES } from '../../initializers/constants'
 import { clearCacheByUserId } from '../../lib/oauth-model'
 import { UserNotificationSettingModel } from './user-notification-setting'
 import { VideoModel } from '../video/video'
 import { ActorModel } from '../activitypub/actor'
 import { ActorFollowModel } from '../activitypub/actor-follow'
 import { VideoImportModel } from '../video/video-import'
+import { UserAdminFlag } from '../../../shared/models/users/user-flag.model'
 
 enum ScopeNames {
   WITH_VIDEO_CHANNEL = 'WITH_VIDEO_CHANNEL'
 }
 
-@DefaultScope({
+@DefaultScope(() => ({
   include: [
     {
-      model: () => AccountModel,
+      model: AccountModel,
       required: true
     },
     {
-      model: () => UserNotificationSettingModel,
+      model: UserNotificationSettingModel,
       required: true
     }
   ]
-})
-@Scopes({
+}))
+@Scopes(() => ({
   [ScopeNames.WITH_VIDEO_CHANNEL]: {
     include: [
       {
-        model: () => AccountModel,
+        model: AccountModel,
         required: true,
-        include: [ () => VideoChannelModel ]
+        include: [ VideoChannelModel ]
       },
       {
-        model: () => UserNotificationSettingModel,
+        model: UserNotificationSettingModel,
         required: true
       }
     ]
   }
-})
+}))
 @Table({
   tableName: 'user',
   indexes: [
@@ -113,13 +115,13 @@ export class UserModel extends Model<UserModel> {
 
   @AllowNull(true)
   @Default(null)
-  @Is('UserEmailVerified', value => throwIfNotValid(value, isUserEmailVerifiedValid, 'email verified boolean'))
+  @Is('UserEmailVerified', value => throwIfNotValid(value, isUserEmailVerifiedValid, 'email verified boolean', true))
   @Column
   emailVerified: boolean
 
   @AllowNull(false)
   @Is('UserNSFWPolicy', value => throwIfNotValid(value, isUserNSFWPolicyValid, 'NSFW policy'))
-  @Column(DataType.ENUM(values(NSFW_POLICY_TYPES)))
+  @Column(DataType.ENUM(...values(NSFW_POLICY_TYPES)))
   nsfwPolicy: NSFWPolicyType
 
   @AllowNull(false)
@@ -141,6 +143,12 @@ export class UserModel extends Model<UserModel> {
   autoPlayVideo: boolean
 
   @AllowNull(false)
+  @Default(UserAdminFlag.NONE)
+  @Is('UserAdminFlags', value => throwIfNotValid(value, isUserAdminFlagsValid, 'user admin flags'))
+  @Column
+  adminFlags?: UserAdminFlag
+
+  @AllowNull(false)
   @Default(false)
   @Is('UserBlocked', value => throwIfNotValid(value, isUserBlockedValid, 'blocked boolean'))
   @Column
@@ -148,7 +156,7 @@ export class UserModel extends Model<UserModel> {
 
   @AllowNull(true)
   @Default(null)
-  @Is('UserBlockedReason', value => throwIfNotValid(value, isUserBlockedReasonValid, 'blocked reason'))
+  @Is('UserBlockedReason', value => throwIfNotValid(value, isUserBlockedReasonValid, 'blocked reason', true))
   @Column
   blockedReason: string
 
@@ -225,26 +233,26 @@ export class UserModel extends Model<UserModel> {
     let where = undefined
     if (search) {
       where = {
-        [Sequelize.Op.or]: [
+        [Op.or]: [
           {
             email: {
-              [Sequelize.Op.iLike]: '%' + search + '%'
+              [Op.iLike]: '%' + search + '%'
             }
           },
           {
             username: {
-              [ Sequelize.Op.iLike ]: '%' + search + '%'
+              [ Op.iLike ]: '%' + search + '%'
             }
           }
         ]
       }
     }
 
-    const query = {
+    const query: FindOptions = {
       attributes: {
         include: [
           [
-            Sequelize.literal(
+            literal(
               '(' +
                 'SELECT COALESCE(SUM("size"), 0) ' +
                 'FROM (' +
@@ -257,7 +265,7 @@ export class UserModel extends Model<UserModel> {
               ')'
             ),
             'videoQuotaUsed'
-          ] as any // FIXME: typings
+          ]
         ]
       },
       offset: start,
@@ -283,7 +291,7 @@ export class UserModel extends Model<UserModel> {
     const query = {
       where: {
         role: {
-          [Sequelize.Op.in]: roles
+          [Op.in]: roles
         }
       }
     }
@@ -341,7 +349,7 @@ export class UserModel extends Model<UserModel> {
   }
 
   static loadById (id: number) {
-    return UserModel.findById(id)
+    return UserModel.findByPk(id)
   }
 
   static loadByUsername (username: string) {
@@ -379,7 +387,7 @@ export class UserModel extends Model<UserModel> {
 
     const query = {
       where: {
-        [ Sequelize.Op.or ]: [ { username }, { email } ]
+        [ Op.or ]: [ { username }, { email } ]
       }
     }
 
@@ -502,7 +510,7 @@ export class UserModel extends Model<UserModel> {
     const query = {
       where: {
         username: {
-          [ Sequelize.Op.like ]: `%${search}%`
+          [ Op.like ]: `%${search}%`
         }
       },
       limit: 10
@@ -516,11 +524,15 @@ export class UserModel extends Model<UserModel> {
     return hasUserRight(this.role, right)
   }
 
+  hasAdminFlag (flag: UserAdminFlag) {
+    return this.adminFlags & flag
+  }
+
   isPasswordMatch (password: string) {
     return comparePassword(password, this.password)
   }
 
-  toFormattedJSON (): User {
+  toFormattedJSON (parameters: { withAdminFlags?: boolean } = {}): User {
     const videoQuotaUsed = this.get('videoQuotaUsed')
     const videoQuotaUsedDaily = this.get('videoQuotaUsedDaily')
 
@@ -544,13 +556,17 @@ export class UserModel extends Model<UserModel> {
       notificationSettings: this.NotificationSetting ? this.NotificationSetting.toFormattedJSON() : undefined,
       videoChannels: [],
       videoQuotaUsed: videoQuotaUsed !== undefined
-            ? parseInt(videoQuotaUsed, 10)
+            ? parseInt(videoQuotaUsed + '', 10)
             : undefined,
       videoQuotaUsedDaily: videoQuotaUsedDaily !== undefined
-            ? parseInt(videoQuotaUsedDaily, 10)
+            ? parseInt(videoQuotaUsedDaily + '', 10)
             : undefined
     }
 
+    if (parameters.withAdminFlags) {
+      Object.assign(json, { adminFlags: this.adminFlags })
+    }
+
     if (Array.isArray(this.Account.VideoChannels) === true) {
       json.videoChannels = this.Account.VideoChannels
         .map(c => c.toFormattedJSON())
@@ -575,15 +591,11 @@ export class UserModel extends Model<UserModel> {
 
     const uploadedTotal = videoFile.size + totalBytes
     const uploadedDaily = videoFile.size + totalBytesDaily
-    if (this.videoQuotaDaily === -1) {
-      return uploadedTotal < this.videoQuota
-    }
-    if (this.videoQuota === -1) {
-      return uploadedDaily < this.videoQuotaDaily
-    }
 
-    return (uploadedTotal < this.videoQuota) &&
-        (uploadedDaily < this.videoQuotaDaily)
+    if (this.videoQuotaDaily === -1) return uploadedTotal < this.videoQuota
+    if (this.videoQuota === -1) return uploadedDaily < this.videoQuotaDaily
+
+    return uploadedTotal < this.videoQuota && uploadedDaily < this.videoQuotaDaily
   }
 
   private static generateUserQuotaBaseSQL (where?: string) {
@@ -603,10 +615,10 @@ export class UserModel extends Model<UserModel> {
   private static getTotalRawQuery (query: string, userId: number) {
     const options = {
       bind: { userId },
-      type: Sequelize.QueryTypes.SELECT
+      type: QueryTypes.SELECT as QueryTypes.SELECT
     }
 
-    return UserModel.sequelize.query(query, options)
+    return UserModel.sequelize.query<{ total: string }>(query, options)
                     .then(([ { total } ]) => {
                       if (total === null) return 0
 
diff --git a/server/models/activitypub/actor-follow.ts b/server/models/activitypub/actor-follow.ts
index 796e07a42..b0461b981 100644
--- a/server/models/activitypub/actor-follow.ts
+++ b/server/models/activitypub/actor-follow.ts
@@ -1,6 +1,5 @@
 import * as Bluebird from 'bluebird'
 import { values } from 'lodash'
-import * as Sequelize from 'sequelize'
 import {
   AfterCreate,
   AfterDestroy,
@@ -22,14 +21,13 @@ import { FollowState } from '../../../shared/models/actors'
 import { ActorFollow } from '../../../shared/models/actors/follow.model'
 import { logger } from '../../helpers/logger'
 import { getServerActor } from '../../helpers/utils'
-import { ACTOR_FOLLOW_SCORE } from '../../initializers'
-import { FOLLOW_STATES } from '../../initializers/constants'
+import { ACTOR_FOLLOW_SCORE, FOLLOW_STATES } from '../../initializers/constants'
 import { ServerModel } from '../server/server'
 import { getSort } from '../utils'
 import { ActorModel, unusedActorAttributesForAPI } from './actor'
 import { VideoChannelModel } from '../video/video-channel'
-import { IIncludeOptions } from '../../../node_modules/sequelize-typescript/lib/interfaces/IIncludeOptions'
 import { AccountModel } from '../account/account'
+import { IncludeOptions, Op, Transaction, QueryTypes } from 'sequelize'
 
 @Table({
   tableName: 'actorFollow',
@@ -52,7 +50,7 @@ import { AccountModel } from '../account/account'
 export class ActorFollowModel extends Model<ActorFollowModel> {
 
   @AllowNull(false)
-  @Column(DataType.ENUM(values(FOLLOW_STATES)))
+  @Column(DataType.ENUM(...values(FOLLOW_STATES)))
   state: FollowState
 
   @AllowNull(false)
@@ -127,7 +125,7 @@ export class ActorFollowModel extends Model<ActorFollowModel> {
     if (numberOfActorFollowsRemoved) logger.info('Removed bad %d actor follows.', numberOfActorFollowsRemoved)
   }
 
-  static loadByActorAndTarget (actorId: number, targetActorId: number, t?: Sequelize.Transaction) {
+  static loadByActorAndTarget (actorId: number, targetActorId: number, t?: Transaction) {
     const query = {
       where: {
         actorId,
@@ -151,8 +149,8 @@ export class ActorFollowModel extends Model<ActorFollowModel> {
     return ActorFollowModel.findOne(query)
   }
 
-  static loadByActorAndTargetNameAndHostForAPI (actorId: number, targetName: string, targetHost: string, t?: Sequelize.Transaction) {
-    const actorFollowingPartInclude: IIncludeOptions = {
+  static loadByActorAndTargetNameAndHostForAPI (actorId: number, targetName: string, targetHost: string, t?: Transaction) {
+    const actorFollowingPartInclude: IncludeOptions = {
       model: ActorModel,
       required: true,
       as: 'ActorFollowing',
@@ -209,7 +207,7 @@ export class ActorFollowModel extends Model<ActorFollowModel> {
       .map(t => {
         if (t.host) {
           return {
-            [ Sequelize.Op.and ]: [
+            [ Op.and ]: [
               {
                 '$preferredUsername$': t.name
               },
@@ -221,7 +219,7 @@ export class ActorFollowModel extends Model<ActorFollowModel> {
         }
 
         return {
-          [ Sequelize.Op.and ]: [
+          [ Op.and ]: [
             {
               '$preferredUsername$': t.name
             },
@@ -235,9 +233,9 @@ export class ActorFollowModel extends Model<ActorFollowModel> {
     const query = {
       attributes: [],
       where: {
-        [ Sequelize.Op.and ]: [
+        [ Op.and ]: [
           {
-            [ Sequelize.Op.or ]: whereTab
+            [ Op.or ]: whereTab
           },
           {
             actorId
@@ -289,7 +287,7 @@ export class ActorFollowModel extends Model<ActorFollowModel> {
               required: true,
               where: search ? {
                 host: {
-                  [Sequelize.Op.iLike]: '%' + search + '%'
+                  [Op.iLike]: '%' + search + '%'
                 }
               } : undefined
             }
@@ -324,7 +322,7 @@ export class ActorFollowModel extends Model<ActorFollowModel> {
               required: true,
               where: search ? {
                 host: {
-                  [ Sequelize.Op.iLike ]: '%' + search + '%'
+                  [ Op.iLike ]: '%' + search + '%'
                 }
               } : undefined
             }
@@ -407,11 +405,11 @@ export class ActorFollowModel extends Model<ActorFollowModel> {
                            })
   }
 
-  static listAcceptedFollowerUrlsForApi (actorIds: number[], t: Sequelize.Transaction, start?: number, count?: number) {
+  static listAcceptedFollowerUrlsForAP (actorIds: number[], t: Transaction, start?: number, count?: number) {
     return ActorFollowModel.createListAcceptedFollowForApiQuery('followers', actorIds, t, start, count)
   }
 
-  static listAcceptedFollowerSharedInboxUrls (actorIds: number[], t: Sequelize.Transaction) {
+  static listAcceptedFollowerSharedInboxUrls (actorIds: number[], t: Transaction) {
     return ActorFollowModel.createListAcceptedFollowForApiQuery(
       'followers',
       actorIds,
@@ -423,7 +421,7 @@ export class ActorFollowModel extends Model<ActorFollowModel> {
     )
   }
 
-  static listAcceptedFollowingUrlsForApi (actorIds: number[], t: Sequelize.Transaction, start?: number, count?: number) {
+  static listAcceptedFollowingUrlsForApi (actorIds: number[], t: Transaction, start?: number, count?: number) {
     return ActorFollowModel.createListAcceptedFollowForApiQuery('following', actorIds, t, start, count)
   }
 
@@ -448,7 +446,7 @@ export class ActorFollowModel extends Model<ActorFollowModel> {
     }
   }
 
-  static updateFollowScore (inboxUrl: string, value: number, t?: Sequelize.Transaction) {
+  static updateFollowScore (inboxUrl: string, value: number, t?: Transaction) {
     const query = `UPDATE "actorFollow" SET "score" = LEAST("score" + ${value}, ${ACTOR_FOLLOW_SCORE.MAX}) ` +
       'WHERE id IN (' +
         'SELECT "actorFollow"."id" FROM "actorFollow" ' +
@@ -457,7 +455,7 @@ export class ActorFollowModel extends Model<ActorFollowModel> {
       ')'
 
     const options = {
-      type: Sequelize.QueryTypes.BULKUPDATE,
+      type: QueryTypes.BULKUPDATE,
       transaction: t
     }
 
@@ -467,7 +465,7 @@ export class ActorFollowModel extends Model<ActorFollowModel> {
   private static async createListAcceptedFollowForApiQuery (
     type: 'followers' | 'following',
     actorIds: number[],
-    t: Sequelize.Transaction,
+    t: Transaction,
     start?: number,
     count?: number,
     columnUrl = 'url',
@@ -503,7 +501,7 @@ export class ActorFollowModel extends Model<ActorFollowModel> {
 
       const options = {
         bind: { actorIds },
-        type: Sequelize.QueryTypes.SELECT,
+        type: QueryTypes.SELECT,
         transaction: t
       }
       tasks.push(ActorFollowModel.sequelize.query(query, options))
@@ -522,7 +520,7 @@ export class ActorFollowModel extends Model<ActorFollowModel> {
     const query = {
       where: {
         score: {
-          [Sequelize.Op.lte]: 0
+          [Op.lte]: 0
         }
       },
       logging: false
diff --git a/server/models/activitypub/actor.ts b/server/models/activitypub/actor.ts
index dda57a8ba..4a466441c 100644
--- a/server/models/activitypub/actor.ts
+++ b/server/models/activitypub/actor.ts
@@ -30,11 +30,11 @@ import {
   isActorPublicKeyValid
 } from '../../helpers/custom-validators/activitypub/actor'
 import { isActivityPubUrlValid } from '../../helpers/custom-validators/activitypub/misc'
-import { ACTIVITY_PUB, ACTIVITY_PUB_ACTOR_TYPES, CONFIG, CONSTRAINTS_FIELDS } from '../../initializers'
+import { ACTIVITY_PUB, ACTIVITY_PUB_ACTOR_TYPES, CONSTRAINTS_FIELDS, WEBSERVER } from '../../initializers/constants'
 import { AccountModel } from '../account/account'
 import { AvatarModel } from '../avatar/avatar'
 import { ServerModel } from '../server/server'
-import { throwIfNotValid } from '../utils'
+import { isOutdated, throwIfNotValid } from '../utils'
 import { VideoChannelModel } from '../video/video-channel'
 import { ActorFollowModel } from './actor-follow'
 import { VideoModel } from '../video/video'
@@ -56,46 +56,46 @@ export const unusedActorAttributesForAPI = [
   'updatedAt'
 ]
 
-@DefaultScope({
+@DefaultScope(() => ({
   include: [
     {
-      model: () => ServerModel,
+      model: ServerModel,
       required: false
     },
     {
-      model: () => AvatarModel,
+      model: AvatarModel,
       required: false
     }
   ]
-})
-@Scopes({
+}))
+@Scopes(() => ({
   [ScopeNames.FULL]: {
     include: [
       {
-        model: () => AccountModel.unscoped(),
+        model: AccountModel.unscoped(),
         required: false
       },
       {
-        model: () => VideoChannelModel.unscoped(),
+        model: VideoChannelModel.unscoped(),
         required: false,
         include: [
           {
-            model: () => AccountModel,
+            model: AccountModel,
             required: true
           }
         ]
       },
       {
-        model: () => ServerModel,
+        model: ServerModel,
         required: false
       },
       {
-        model: () => AvatarModel,
+        model: AvatarModel,
         required: false
       }
     ]
   }
-})
+}))
 @Table({
   tableName: 'actor',
   indexes: [
@@ -131,7 +131,7 @@ export const unusedActorAttributesForAPI = [
 export class ActorModel extends Model<ActorModel> {
 
   @AllowNull(false)
-  @Column(DataType.ENUM(values(ACTIVITY_PUB_ACTOR_TYPES)))
+  @Column(DataType.ENUM(...values(ACTIVITY_PUB_ACTOR_TYPES)))
   type: ActivityPubActorType
 
   @AllowNull(false)
@@ -151,12 +151,12 @@ export class ActorModel extends Model<ActorModel> {
   url: string
 
   @AllowNull(true)
-  @Is('ActorPublicKey', value => throwIfNotValid(value, isActorPublicKeyValid, 'public key'))
+  @Is('ActorPublicKey', value => throwIfNotValid(value, isActorPublicKeyValid, 'public key', true))
   @Column(DataType.STRING(CONSTRAINTS_FIELDS.ACTORS.PUBLIC_KEY.max))
   publicKey: string
 
   @AllowNull(true)
-  @Is('ActorPublicKey', value => throwIfNotValid(value, isActorPrivateKeyValid, 'private key'))
+  @Is('ActorPublicKey', value => throwIfNotValid(value, isActorPrivateKeyValid, 'private key', true))
   @Column(DataType.STRING(CONSTRAINTS_FIELDS.ACTORS.PRIVATE_KEY.max))
   privateKey: string
 
@@ -265,7 +265,7 @@ export class ActorModel extends Model<ActorModel> {
   VideoChannel: VideoChannelModel
 
   static load (id: number) {
-    return ActorModel.unscoped().findById(id)
+    return ActorModel.unscoped().findByPk(id)
   }
 
   static loadAccountActorByVideoId (videoId: number, transaction: Sequelize.Transaction) {
@@ -280,14 +280,16 @@ export class ActorModel extends Model<ActorModel> {
               attributes: [ 'id' ],
               model: VideoChannelModel.unscoped(),
               required: true,
-              include: {
-                attributes: [ 'id' ],
-                model: VideoModel.unscoped(),
-                required: true,
-                where: {
-                  id: videoId
+              include: [
+                {
+                  attributes: [ 'id' ],
+                  model: VideoModel.unscoped(),
+                  required: true,
+                  where: {
+                    id: videoId
+                  }
                 }
-              }
+              ]
             }
           ]
         }
@@ -295,7 +297,7 @@ export class ActorModel extends Model<ActorModel> {
       transaction
     }
 
-    return ActorModel.unscoped().findOne(query as any) // FIXME: typings
+    return ActorModel.unscoped().findOne(query)
   }
 
   static isActorUrlExist (url: string) {
@@ -389,8 +391,7 @@ export class ActorModel extends Model<ActorModel> {
   }
 
   static incrementFollows (id: number, column: 'followersCount' | 'followingCount', by: number) {
-    // FIXME: typings
-    return (ActorModel as any).increment(column, {
+    return ActorModel.increment(column, {
       by,
       where: {
         id
@@ -444,6 +445,7 @@ export class ActorModel extends Model<ActorModel> {
       id: this.url,
       following: this.getFollowingUrl(),
       followers: this.getFollowersUrl(),
+      playlists: this.getPlaylistsUrl(),
       inbox: this.inboxUrl,
       outbox: this.outboxUrl,
       preferredUsername: this.preferredUsername,
@@ -494,6 +496,10 @@ export class ActorModel extends Model<ActorModel> {
     return this.url + '/followers'
   }
 
+  getPlaylistsUrl () {
+    return this.url + '/playlists'
+  }
+
   getPublicKeyUrl () {
     return this.url + '#main-key'
   }
@@ -511,7 +517,7 @@ export class ActorModel extends Model<ActorModel> {
   }
 
   getHost () {
-    return this.Server ? this.Server.host : CONFIG.WEBSERVER.HOST
+    return this.Server ? this.Server.host : WEBSERVER.HOST
   }
 
   getRedundancyAllowed () {
@@ -521,17 +527,12 @@ export class ActorModel extends Model<ActorModel> {
   getAvatarUrl () {
     if (!this.avatarId) return undefined
 
-    return CONFIG.WEBSERVER.URL + this.Avatar.getWebserverPath()
+    return WEBSERVER.URL + this.Avatar.getWebserverPath()
   }
 
   isOutdated () {
     if (this.isOwned()) return false
 
-    const now = Date.now()
-    const createdAtTime = this.createdAt.getTime()
-    const updatedAtTime = this.updatedAt.getTime()
-
-    return (now - createdAtTime) > ACTIVITY_PUB.ACTOR_REFRESH_INTERVAL &&
-      (now - updatedAtTime) > ACTIVITY_PUB.ACTOR_REFRESH_INTERVAL
+    return isOutdated(this, ACTIVITY_PUB.ACTOR_REFRESH_INTERVAL)
   }
 }
diff --git a/server/models/application/application.ts b/server/models/application/application.ts
index 854a5fb36..81320b9af 100644
--- a/server/models/application/application.ts
+++ b/server/models/application/application.ts
@@ -1,16 +1,17 @@
 import { AllowNull, Column, Default, DefaultScope, HasOne, IsInt, Model, Table } from 'sequelize-typescript'
 import { AccountModel } from '../account/account'
 
-@DefaultScope({
+@DefaultScope(() => ({
   include: [
     {
-      model: () => AccountModel,
+      model: AccountModel,
       required: true
     }
   ]
-})
+}))
 @Table({
-  tableName: 'application'
+  tableName: 'application',
+  timestamps: false
 })
 export class ApplicationModel extends Model<ApplicationModel> {
 
diff --git a/server/models/avatar/avatar.ts b/server/models/avatar/avatar.ts
index 303aebcc2..aaf1b8bd9 100644
--- a/server/models/avatar/avatar.ts
+++ b/server/models/avatar/avatar.ts
@@ -1,9 +1,10 @@
 import { join } from 'path'
 import { AfterDestroy, AllowNull, Column, CreatedAt, Model, Table, UpdatedAt } from 'sequelize-typescript'
 import { Avatar } from '../../../shared/models/avatars/avatar.model'
-import { CONFIG, STATIC_PATHS } from '../../initializers'
+import { STATIC_PATHS } from '../../initializers/constants'
 import { logger } from '../../helpers/logger'
 import { remove } from 'fs-extra'
+import { CONFIG } from '../../initializers/config'
 
 @Table({
   tableName: 'avatar'
diff --git a/server/models/migrations.ts b/server/models/migrations.ts
index 24badb166..6c11332a1 100644
--- a/server/models/migrations.ts
+++ b/server/models/migrations.ts
@@ -1,24 +1,24 @@
-import * as Sequelize from 'sequelize'
+import { ModelAttributeColumnOptions } from 'sequelize'
 
 declare namespace Migration {
-  interface Boolean extends Sequelize.DefineAttributeColumnOptions {
+  interface Boolean extends ModelAttributeColumnOptions {
     defaultValue: boolean | null
   }
 
-  interface String extends Sequelize.DefineAttributeColumnOptions {
+  interface String extends ModelAttributeColumnOptions {
     defaultValue: string | null
   }
 
-  interface Integer extends Sequelize.DefineAttributeColumnOptions {
+  interface Integer extends ModelAttributeColumnOptions {
     defaultValue: number | null
   }
 
-  interface BigInteger extends Sequelize.DefineAttributeColumnOptions {
-    defaultValue: Sequelize.DataTypeBigInt | number | null
+  interface BigInteger extends ModelAttributeColumnOptions {
+    defaultValue: number | null
   }
 
-  interface UUID extends Sequelize.DefineAttributeColumnOptions {
-    defaultValue: Sequelize.DataTypeUUIDv4 | null
+  interface UUID extends ModelAttributeColumnOptions {
+    defaultValue: null
   }
 }
 
diff --git a/server/models/oauth/oauth-token.ts b/server/models/oauth/oauth-token.ts
index 08d892da4..903d551df 100644
--- a/server/models/oauth/oauth-token.ts
+++ b/server/models/oauth/oauth-token.ts
@@ -34,21 +34,21 @@ enum ScopeNames {
   WITH_USER = 'WITH_USER'
 }
 
-@Scopes({
+@Scopes(() => ({
   [ScopeNames.WITH_USER]: {
     include: [
       {
-        model: () => UserModel.unscoped(),
+        model: UserModel.unscoped(),
         required: true,
         include: [
           {
             attributes: [ 'id' ],
-            model: () => AccountModel.unscoped(),
+            model: AccountModel.unscoped(),
             required: true,
             include: [
               {
                 attributes: [ 'id', 'url' ],
-                model: () => ActorModel.unscoped(),
+                model: ActorModel.unscoped(),
                 required: true
               }
             ]
@@ -57,7 +57,7 @@ enum ScopeNames {
       }
     ]
   }
-})
+}))
 @Table({
   tableName: 'oAuthToken',
   indexes: [
@@ -167,11 +167,13 @@ export class OAuthTokenModel extends Model<OAuthTokenModel> {
       }
     }
 
-    return OAuthTokenModel.scope(ScopeNames.WITH_USER).findOne(query).then(token => {
-      if (token) token['user'] = token.User
+    return OAuthTokenModel.scope(ScopeNames.WITH_USER)
+                          .findOne(query)
+                          .then(token => {
+                            if (token) token[ 'user' ] = token.User
 
-      return token
-    })
+                            return token
+                          })
   }
 
   static getByRefreshTokenAndPopulateUser (refreshToken: string) {
diff --git a/server/models/redundancy/video-redundancy.ts b/server/models/redundancy/video-redundancy.ts
index 8f2ef2d9a..eb2222256 100644
--- a/server/models/redundancy/video-redundancy.ts
+++ b/server/models/redundancy/video-redundancy.ts
@@ -13,9 +13,9 @@ import {
   UpdatedAt
 } from 'sequelize-typescript'
 import { ActorModel } from '../activitypub/actor'
-import { getVideoSort, throwIfNotValid } from '../utils'
+import { getVideoSort, parseAggregateResult, throwIfNotValid } from '../utils'
 import { isActivityPubUrlValid, isUrlValid } from '../../helpers/custom-validators/activitypub/misc'
-import { CONFIG, CONSTRAINTS_FIELDS, MIMETYPES } from '../../initializers'
+import { CONSTRAINTS_FIELDS, MIMETYPES } from '../../initializers/constants'
 import { VideoFileModel } from '../video/video-file'
 import { getServerActor } from '../../helpers/utils'
 import { VideoModel } from '../video/video'
@@ -27,28 +27,40 @@ import { ServerModel } from '../server/server'
 import { sample } from 'lodash'
 import { isTestInstance } from '../../helpers/core-utils'
 import * as Bluebird from 'bluebird'
-import * as Sequelize from 'sequelize'
+import { col, FindOptions, fn, literal, Op, Transaction } from 'sequelize'
+import { VideoStreamingPlaylistModel } from '../video/video-streaming-playlist'
+import { CONFIG } from '../../initializers/config'
 
 export enum ScopeNames {
   WITH_VIDEO = 'WITH_VIDEO'
 }
 
-@Scopes({
+@Scopes(() => ({
   [ ScopeNames.WITH_VIDEO ]: {
     include: [
       {
-        model: () => VideoFileModel,
-        required: true,
+        model: VideoFileModel,
+        required: false,
         include: [
           {
-            model: () => VideoModel,
+            model: VideoModel,
+            required: true
+          }
+        ]
+      },
+      {
+        model: VideoStreamingPlaylistModel,
+        required: false,
+        include: [
+          {
+            model: VideoModel,
             required: true
           }
         ]
       }
     ]
   }
-})
+}))
 
 @Table({
   tableName: 'videoRedundancy',
@@ -97,12 +109,24 @@ export class VideoRedundancyModel extends Model<VideoRedundancyModel> {
 
   @BelongsTo(() => VideoFileModel, {
     foreignKey: {
-      allowNull: false
+      allowNull: true
     },
     onDelete: 'cascade'
   })
   VideoFile: VideoFileModel
 
+  @ForeignKey(() => VideoStreamingPlaylistModel)
+  @Column
+  videoStreamingPlaylistId: number
+
+  @BelongsTo(() => VideoStreamingPlaylistModel, {
+    foreignKey: {
+      allowNull: true
+    },
+    onDelete: 'cascade'
+  })
+  VideoStreamingPlaylist: VideoStreamingPlaylistModel
+
   @ForeignKey(() => ActorModel)
   @Column
   actorId: number
@@ -119,13 +143,25 @@ export class VideoRedundancyModel extends Model<VideoRedundancyModel> {
   static async removeFile (instance: VideoRedundancyModel) {
     if (!instance.isOwned()) return
 
-    const videoFile = await VideoFileModel.loadWithVideo(instance.videoFileId)
+    if (instance.videoFileId) {
+      const videoFile = await VideoFileModel.loadWithVideo(instance.videoFileId)
 
-    const logIdentifier = `${videoFile.Video.uuid}-${videoFile.resolution}`
-    logger.info('Removing duplicated video file %s.', logIdentifier)
+      const logIdentifier = `${videoFile.Video.uuid}-${videoFile.resolution}`
+      logger.info('Removing duplicated video file %s.', logIdentifier)
 
-    videoFile.Video.removeFile(videoFile, true)
-             .catch(err => logger.error('Cannot delete %s files.', logIdentifier, { err }))
+      videoFile.Video.removeFile(videoFile, true)
+               .catch(err => logger.error('Cannot delete %s files.', logIdentifier, { err }))
+    }
+
+    if (instance.videoStreamingPlaylistId) {
+      const videoStreamingPlaylist = await VideoStreamingPlaylistModel.loadWithVideo(instance.videoStreamingPlaylistId)
+
+      const videoUUID = videoStreamingPlaylist.Video.uuid
+      logger.info('Removing duplicated video streaming playlist %s.', videoUUID)
+
+      videoStreamingPlaylist.Video.removeStreamingPlaylist(true)
+               .catch(err => logger.error('Cannot delete video streaming playlist files of %s.', videoUUID, { err }))
+    }
 
     return undefined
   }
@@ -143,7 +179,20 @@ export class VideoRedundancyModel extends Model<VideoRedundancyModel> {
     return VideoRedundancyModel.scope(ScopeNames.WITH_VIDEO).findOne(query)
   }
 
-  static loadByUrl (url: string, transaction?: Sequelize.Transaction) {
+  static async loadLocalByStreamingPlaylistId (videoStreamingPlaylistId: number) {
+    const actor = await getServerActor()
+
+    const query = {
+      where: {
+        actorId: actor.id,
+        videoStreamingPlaylistId
+      }
+    }
+
+    return VideoRedundancyModel.scope(ScopeNames.WITH_VIDEO).findOne(query)
+  }
+
+  static loadByUrl (url: string, transaction?: Transaction) {
     const query = {
       where: {
         url
@@ -191,7 +240,7 @@ export class VideoRedundancyModel extends Model<VideoRedundancyModel> {
     const ids = rows.map(r => r.id)
     const id = sample(ids)
 
-    return VideoModel.loadWithFile(id, undefined, !isTestInstance())
+    return VideoModel.loadWithFiles(id, undefined, !isTestInstance())
   }
 
   static async findMostViewToDuplicate (randomizedFactor: number) {
@@ -243,7 +292,7 @@ export class VideoRedundancyModel extends Model<VideoRedundancyModel> {
       where: {
         privacy: VideoPrivacy.PUBLIC,
         views: {
-          [ Sequelize.Op.gte ]: minViews
+          [ Op.gte ]: minViews
         }
       },
       include: [
@@ -266,7 +315,7 @@ export class VideoRedundancyModel extends Model<VideoRedundancyModel> {
         actorId: actor.id,
         strategy,
         createdAt: {
-          [ Sequelize.Op.lt ]: expiredDate
+          [ Op.lt ]: expiredDate
         }
       }
     }
@@ -277,7 +326,7 @@ export class VideoRedundancyModel extends Model<VideoRedundancyModel> {
   static async getTotalDuplicated (strategy: VideoRedundancyStrategy) {
     const actor = await getServerActor()
 
-    const options = {
+    const query: FindOptions = {
       include: [
         {
           attributes: [],
@@ -291,12 +340,8 @@ export class VideoRedundancyModel extends Model<VideoRedundancyModel> {
       ]
     }
 
-    return VideoFileModel.sum('size', options as any) // FIXME: typings
-      .then(v => {
-        if (!v || isNaN(v)) return 0
-
-        return v
-      })
+    return VideoFileModel.aggregate('size', 'SUM', query)
+      .then(result => parseAggregateResult(result))
   }
 
   static async listLocalExpired () {
@@ -306,7 +351,7 @@ export class VideoRedundancyModel extends Model<VideoRedundancyModel> {
       where: {
         actorId: actor.id,
         expiresOn: {
-          [ Sequelize.Op.lt ]: new Date()
+          [ Op.lt ]: new Date()
         }
       }
     }
@@ -320,10 +365,10 @@ export class VideoRedundancyModel extends Model<VideoRedundancyModel> {
     const query = {
       where: {
         actorId: {
-          [Sequelize.Op.ne]: actor.id
+          [Op.ne]: actor.id
         },
         expiresOn: {
-          [ Sequelize.Op.lt ]: new Date()
+          [ Op.lt ]: new Date()
         }
       }
     }
@@ -333,40 +378,44 @@ export class VideoRedundancyModel extends Model<VideoRedundancyModel> {
 
   static async listLocalOfServer (serverId: number) {
     const actor = await getServerActor()
-
-    const query = {
-      where: {
-        actorId: actor.id
-      },
+    const buildVideoInclude = () => ({
+      model: VideoModel,
+      required: true,
       include: [
         {
-          model: VideoFileModel,
+          attributes: [],
+          model: VideoChannelModel.unscoped(),
           required: true,
           include: [
             {
-              model: VideoModel,
+              attributes: [],
+              model: ActorModel.unscoped(),
               required: true,
-              include: [
-                {
-                  attributes: [],
-                  model: VideoChannelModel.unscoped(),
-                  required: true,
-                  include: [
-                    {
-                      attributes: [],
-                      model: ActorModel.unscoped(),
-                      required: true,
-                      where: {
-                        serverId
-                      }
-                    }
-                  ]
-                }
-              ]
+              where: {
+                serverId
+              }
             }
           ]
         }
       ]
+    })
+
+    const query = {
+      where: {
+        actorId: actor.id
+      },
+      include: [
+        {
+          model: VideoFileModel,
+          required: false,
+          include: [ buildVideoInclude() ]
+        },
+        {
+          model: VideoStreamingPlaylistModel,
+          required: false,
+          include: [ buildVideoInclude() ]
+        }
+      ]
     }
 
     return VideoRedundancyModel.findAll(query)
@@ -375,12 +424,12 @@ export class VideoRedundancyModel extends Model<VideoRedundancyModel> {
   static async getStats (strategy: VideoRedundancyStrategy) {
     const actor = await getServerActor()
 
-    const query = {
+    const query: FindOptions = {
       raw: true,
       attributes: [
-        [ Sequelize.fn('COALESCE', Sequelize.fn('SUM', Sequelize.col('VideoFile.size')), '0'), 'totalUsed' ],
-        [ Sequelize.fn('COUNT', Sequelize.fn('DISTINCT', Sequelize.col('videoId'))), 'totalVideos' ],
-        [ Sequelize.fn('COUNT', Sequelize.col('videoFileId')), 'totalVideoFiles' ]
+        [ fn('COALESCE', fn('SUM', col('VideoFile.size')), '0'), 'totalUsed' ],
+        [ fn('COUNT', fn('DISTINCT', col('videoId'))), 'totalVideos' ],
+        [ fn('COUNT', col('videoFileId')), 'totalVideoFiles' ]
       ],
       where: {
         strategy,
@@ -395,19 +444,40 @@ export class VideoRedundancyModel extends Model<VideoRedundancyModel> {
       ]
     }
 
-    return VideoRedundancyModel.findOne(query as any) // FIXME: typings
+    return VideoRedundancyModel.findOne(query)
       .then((r: any) => ({
-        totalUsed: parseInt(r.totalUsed.toString(), 10),
+        totalUsed: parseAggregateResult(r.totalUsed),
         totalVideos: r.totalVideos,
         totalVideoFiles: r.totalVideoFiles
       }))
   }
 
+  getVideo () {
+    if (this.VideoFile) return this.VideoFile.Video
+
+    return this.VideoStreamingPlaylist.Video
+  }
+
   isOwned () {
     return !!this.strategy
   }
 
   toActivityPubObject (): CacheFileObject {
+    if (this.VideoStreamingPlaylist) {
+      return {
+        id: this.url,
+        type: 'CacheFile' as 'CacheFile',
+        object: this.VideoStreamingPlaylist.Video.url,
+        expires: this.expiresOn.toISOString(),
+        url: {
+          type: 'Link',
+          mimeType: 'application/x-mpegURL',
+          mediaType: 'application/x-mpegURL',
+          href: this.fileUrl
+        }
+      }
+    }
+
     return {
       id: this.url,
       type: 'CacheFile' as 'CacheFile',
@@ -429,9 +499,9 @@ export class VideoRedundancyModel extends Model<VideoRedundancyModel> {
   private static async buildVideoFileForDuplication () {
     const actor = await getServerActor()
 
-    const notIn = Sequelize.literal(
+    const notIn = literal(
       '(' +
-        `SELECT "videoFileId" FROM "videoRedundancy" WHERE "actorId" = ${actor.id}` +
+        `SELECT "videoFileId" FROM "videoRedundancy" WHERE "actorId" = ${actor.id} AND "videoFileId" IS NOT NULL` +
       ')'
     )
 
@@ -441,7 +511,7 @@ export class VideoRedundancyModel extends Model<VideoRedundancyModel> {
       required: true,
       where: {
         id: {
-          [ Sequelize.Op.notIn ]: notIn
+          [ Op.notIn ]: notIn
         }
       }
     }
diff --git a/server/models/server/server-blocklist.ts b/server/models/server/server-blocklist.ts
index 450f27152..92c01f642 100644
--- a/server/models/server/server-blocklist.ts
+++ b/server/models/server/server-blocklist.ts
@@ -9,11 +9,11 @@ enum ScopeNames {
   WITH_SERVER = 'WITH_SERVER'
 }
 
-@Scopes({
+@Scopes(() => ({
   [ScopeNames.WITH_ACCOUNT]: {
     include: [
       {
-        model: () => AccountModel,
+        model: AccountModel,
         required: true
       }
     ]
@@ -21,12 +21,12 @@ enum ScopeNames {
   [ScopeNames.WITH_SERVER]: {
     include: [
       {
-        model: () => ServerModel,
+        model: ServerModel,
         required: true
       }
     ]
   }
-})
+}))
 
 @Table({
   tableName: 'serverBlocklist',
diff --git a/server/models/utils.ts b/server/models/utils.ts
index 5b4093aec..2b172f608 100644
--- a/server/models/utils.ts
+++ b/server/models/utils.ts
@@ -1,25 +1,29 @@
 import { Sequelize } from 'sequelize-typescript'
+import * as validator from 'validator'
+import { OrderItem } from 'sequelize'
+import { Col } from 'sequelize/types/lib/utils'
 
 type SortType = { sortModel: any, sortValue: string }
 
 // Translate for example "-name" to [ [ 'name', 'DESC' ], [ 'id', 'ASC' ] ]
-function getSort (value: string, lastSort: string[] = [ 'id', 'ASC' ]) {
-  let { direction, field } = buildDirectionAndField(value)
+function getSort (value: string, lastSort: OrderItem = [ 'id', 'ASC' ]): OrderItem[] {
+  const { direction, field } = buildDirectionAndField(value)
+
+  let finalField: string | Col
 
   if (field.toLowerCase() === 'match') { // Search
-    field = Sequelize.col('similarity')
+    finalField = Sequelize.col('similarity')
+  } else {
+    finalField = field
   }
 
-  return [ [ field, direction ], lastSort ]
+  return [ [ finalField, direction ], lastSort ]
 }
 
-function getVideoSort (value: string, lastSort: string[] = [ 'id', 'ASC' ]) {
-  let { direction, field } = buildDirectionAndField(value)
+function getVideoSort (value: string, lastSort: OrderItem = [ 'id', 'ASC' ]): OrderItem[] {
+  const { direction, field } = buildDirectionAndField(value)
 
-  // Alias
-  if (field.toLowerCase() === 'match') { // Search
-    field = Sequelize.col('similarity')
-  } else if (field.toLowerCase() === 'trending') { // Sort by aggregation
+  if (field.toLowerCase() === 'trending') { // Sort by aggregation
     return [
       [ Sequelize.fn('COALESCE', Sequelize.fn('SUM', Sequelize.col('VideoViews.views')), '0'), direction ],
 
@@ -29,21 +33,40 @@ function getVideoSort (value: string, lastSort: string[] = [ 'id', 'ASC' ]) {
     ]
   }
 
-  const firstSort = typeof field === 'string' ?
-    field.split('.').concat([ direction ]) :
-    [ field, direction ]
+  let finalField: string | Col
+
+  // Alias
+  if (field.toLowerCase() === 'match') { // Search
+    finalField = Sequelize.col('similarity')
+  } else {
+    finalField = field
+  }
+
+  const firstSort = typeof finalField === 'string'
+    ? finalField.split('.').concat([ direction ]) as any // FIXME: sequelize typings
+    : [ finalField, direction ]
 
   return [ firstSort, lastSort ]
 }
 
-function getSortOnModel (model: any, value: string, lastSort: string[] = [ 'id', 'ASC' ]) {
-  let [ firstSort ] = getSort(value)
+function getSortOnModel (model: any, value: string, lastSort: OrderItem = [ 'id', 'ASC' ]): OrderItem[] {
+  const [ firstSort ] = getSort(value)
 
   if (model) return [ [ model, firstSort[0], firstSort[1] ], lastSort ]
   return [ firstSort, lastSort ]
 }
 
-function throwIfNotValid (value: any, validator: (value: any) => boolean, fieldName = 'value') {
+function isOutdated (model: { createdAt: Date, updatedAt: Date }, refreshInterval: number) {
+  const now = Date.now()
+  const createdAtTime = model.createdAt.getTime()
+  const updatedAtTime = model.updatedAt.getTime()
+
+  return (now - createdAtTime) > refreshInterval && (now - updatedAtTime) > refreshInterval
+}
+
+function throwIfNotValid (value: any, validator: (value: any) => boolean, fieldName = 'value', nullable = false) {
+  if (nullable && (value === null || value === undefined)) return
+
   if (validator(value) === false) {
     throw new Error(`"${value}" is not a valid ${fieldName}.`)
   }
@@ -74,13 +97,34 @@ function buildBlockedAccountSQL (serverAccountId: number, userAccountId?: number
 
   const blockerIdsString = blockerIds.join(', ')
 
-  const query = 'SELECT "targetAccountId" AS "id" FROM "accountBlocklist" WHERE "accountId" IN (' + blockerIdsString + ')' +
+  return 'SELECT "targetAccountId" AS "id" FROM "accountBlocklist" WHERE "accountId" IN (' + blockerIdsString + ')' +
     ' UNION ALL ' +
     'SELECT "account"."id" AS "id" FROM account INNER JOIN "actor" ON account."actorId" = actor.id ' +
     'INNER JOIN "serverBlocklist" ON "actor"."serverId" = "serverBlocklist"."targetServerId" ' +
     'WHERE "serverBlocklist"."accountId" IN (' + blockerIdsString + ')'
+}
+
+function buildServerIdsFollowedBy (actorId: any) {
+  const actorIdNumber = parseInt(actorId + '', 10)
+
+  return '(' +
+    'SELECT "actor"."serverId" FROM "actorFollow" ' +
+    'INNER JOIN "actor" ON actor.id = "actorFollow"."targetActorId" ' +
+    'WHERE "actorFollow"."actorId" = ' + actorIdNumber +
+  ')'
+}
+
+function buildWhereIdOrUUID (id: number | string) {
+  return validator.isInt('' + id) ? { id } : { uuid: id }
+}
+
+function parseAggregateResult (result: any) {
+  if (!result) return 0
+
+  const total = parseInt(result + '', 10)
+  if (isNaN(total)) return 0
 
-  return query
+  return total
 }
 
 // ---------------------------------------------------------------------------
@@ -93,7 +137,11 @@ export {
   getSortOnModel,
   createSimilarityAttribute,
   throwIfNotValid,
-  buildTrigramSearchIndex
+  buildServerIdsFollowedBy,
+  buildTrigramSearchIndex,
+  buildWhereIdOrUUID,
+  isOutdated,
+  parseAggregateResult
 }
 
 // ---------------------------------------------------------------------------
@@ -107,7 +155,7 @@ function searchTrigramNormalizeCol (col: string) {
 }
 
 function buildDirectionAndField (value: string) {
-  let field: any
+  let field: string
   let direction: 'ASC' | 'DESC'
 
   if (value.substring(0, 1) === '-') {
diff --git a/server/models/video/schedule-video-update.ts b/server/models/video/schedule-video-update.ts
index 1e56562e1..603d55692 100644
--- a/server/models/video/schedule-video-update.ts
+++ b/server/models/video/schedule-video-update.ts
@@ -1,7 +1,7 @@
-import { AllowNull, BelongsTo, Column, CreatedAt, Default, ForeignKey, Model, Sequelize, Table, UpdatedAt } from 'sequelize-typescript'
+import { AllowNull, BelongsTo, Column, CreatedAt, Default, ForeignKey, Model, Table, UpdatedAt } from 'sequelize-typescript'
 import { ScopeNames as VideoScopeNames, VideoModel } from './video'
 import { VideoPrivacy } from '../../../shared/models/videos'
-import { Transaction } from 'sequelize'
+import { Op, Transaction } from 'sequelize'
 
 @Table({
   tableName: 'scheduleVideoUpdate',
@@ -51,7 +51,7 @@ export class ScheduleVideoUpdateModel extends Model<ScheduleVideoUpdateModel> {
       attributes: [ 'id' ],
       where: {
         updateAt: {
-          [Sequelize.Op.lte]: new Date()
+          [Op.lte]: new Date()
         }
       }
     }
@@ -64,7 +64,7 @@ export class ScheduleVideoUpdateModel extends Model<ScheduleVideoUpdateModel> {
     const query = {
       where: {
         updateAt: {
-          [Sequelize.Op.lte]: new Date()
+          [Op.lte]: new Date()
         }
       },
       include: [
@@ -72,7 +72,9 @@ export class ScheduleVideoUpdateModel extends Model<ScheduleVideoUpdateModel> {
           model: VideoModel.scope(
             [
               VideoScopeNames.WITH_FILES,
-              VideoScopeNames.WITH_ACCOUNT_DETAILS
+              VideoScopeNames.WITH_ACCOUNT_DETAILS,
+              VideoScopeNames.WITH_BLACKLISTED,
+              VideoScopeNames.WITH_THUMBNAILS
             ]
           )
         }
diff --git a/server/models/video/tag.ts b/server/models/video/tag.ts
index b39621eaf..0fc3cfd4c 100644
--- a/server/models/video/tag.ts
+++ b/server/models/video/tag.ts
@@ -1,5 +1,5 @@
 import * as Bluebird from 'bluebird'
-import * as Sequelize from 'sequelize'
+import { QueryTypes, Transaction } from 'sequelize'
 import { AllowNull, BelongsToMany, Column, CreatedAt, Is, Model, Table, UpdatedAt } from 'sequelize-typescript'
 import { isVideoTagValid } from '../../helpers/custom-validators/videos'
 import { throwIfNotValid } from '../utils'
@@ -37,7 +37,7 @@ export class TagModel extends Model<TagModel> {
   })
   Videos: VideoModel[]
 
-  static findOrCreateTags (tags: string[], transaction: Sequelize.Transaction) {
+  static findOrCreateTags (tags: string[], transaction: Transaction) {
     if (tags === null) return []
 
     const tasks: Bluebird<TagModel>[] = []
@@ -72,10 +72,10 @@ export class TagModel extends Model<TagModel> {
 
     const options = {
       bind: { threshold, count, videoPrivacy: VideoPrivacy.PUBLIC, videoState: VideoState.PUBLISHED },
-      type: Sequelize.QueryTypes.SELECT
+      type: QueryTypes.SELECT as QueryTypes.SELECT
     }
 
-    return TagModel.sequelize.query(query, options)
+    return TagModel.sequelize.query<{ name: string }>(query, options)
                     .then(data => data.map(d => d.name))
   }
 }
diff --git a/server/models/video/thumbnail.ts b/server/models/video/thumbnail.ts
new file mode 100644
index 000000000..206e9a3d6
--- /dev/null
+++ b/server/models/video/thumbnail.ts
@@ -0,0 +1,116 @@
+import { join } from 'path'
+import { AfterDestroy, AllowNull, BelongsTo, Column, CreatedAt, Default, ForeignKey, Model, Table, UpdatedAt } from 'sequelize-typescript'
+import { STATIC_PATHS, WEBSERVER } from '../../initializers/constants'
+import { logger } from '../../helpers/logger'
+import { remove } from 'fs-extra'
+import { CONFIG } from '../../initializers/config'
+import { VideoModel } from './video'
+import { VideoPlaylistModel } from './video-playlist'
+import { ThumbnailType } from '../../../shared/models/videos/thumbnail.type'
+
+@Table({
+  tableName: 'thumbnail',
+  indexes: [
+    {
+      fields: [ 'videoId' ]
+    },
+    {
+      fields: [ 'videoPlaylistId' ],
+      unique: true
+    }
+  ]
+})
+export class ThumbnailModel extends Model<ThumbnailModel> {
+
+  @AllowNull(false)
+  @Column
+  filename: string
+
+  @AllowNull(true)
+  @Default(null)
+  @Column
+  height: number
+
+  @AllowNull(true)
+  @Default(null)
+  @Column
+  width: number
+
+  @AllowNull(false)
+  @Column
+  type: ThumbnailType
+
+  @AllowNull(true)
+  @Column
+  fileUrl: string
+
+  @ForeignKey(() => VideoModel)
+  @Column
+  videoId: number
+
+  @BelongsTo(() => VideoModel, {
+    foreignKey: {
+      allowNull: true
+    },
+    onDelete: 'CASCADE'
+  })
+  Video: VideoModel
+
+  @ForeignKey(() => VideoPlaylistModel)
+  @Column
+  videoPlaylistId: number
+
+  @BelongsTo(() => VideoPlaylistModel, {
+    foreignKey: {
+      allowNull: true
+    },
+    onDelete: 'CASCADE'
+  })
+  VideoPlaylist: VideoPlaylistModel
+
+  @CreatedAt
+  createdAt: Date
+
+  @UpdatedAt
+  updatedAt: Date
+
+  private static types: { [ id in ThumbnailType ]: { label: string, directory: string, staticPath: string } } = {
+    [ThumbnailType.MINIATURE]: {
+      label: 'miniature',
+      directory: CONFIG.STORAGE.THUMBNAILS_DIR,
+      staticPath: STATIC_PATHS.THUMBNAILS
+    },
+    [ThumbnailType.PREVIEW]: {
+      label: 'preview',
+      directory: CONFIG.STORAGE.PREVIEWS_DIR,
+      staticPath: STATIC_PATHS.PREVIEWS
+    }
+  }
+
+  @AfterDestroy
+  static removeFilesAndSendDelete (instance: ThumbnailModel) {
+    logger.info('Removing %s file %s.', ThumbnailModel.types[instance.type].label, instance.filename)
+
+    // Don't block the transaction
+    instance.removeThumbnail()
+            .catch(err => logger.error('Cannot remove thumbnail file %s.', instance.filename, err))
+  }
+
+  static generateDefaultPreviewName (videoUUID: string) {
+    return videoUUID + '.jpg'
+  }
+
+  getFileUrl () {
+    if (this.fileUrl) return this.fileUrl
+
+    const staticPath = ThumbnailModel.types[this.type].staticPath
+    return WEBSERVER.URL + staticPath + this.filename
+  }
+
+  removeThumbnail () {
+    const directory = ThumbnailModel.types[this.type].directory
+    const thumbnailPath = join(directory, this.filename)
+
+    return remove(thumbnailPath)
+  }
+}
diff --git a/server/models/video/video-abuse.ts b/server/models/video/video-abuse.ts
index cc47644f2..1ac7919b3 100644
--- a/server/models/video/video-abuse.ts
+++ b/server/models/video/video-abuse.ts
@@ -10,7 +10,7 @@ import { AccountModel } from '../account/account'
 import { getSort, throwIfNotValid } from '../utils'
 import { VideoModel } from './video'
 import { VideoAbuseState } from '../../../shared'
-import { CONSTRAINTS_FIELDS, VIDEO_ABUSE_STATES } from '../../initializers'
+import { CONSTRAINTS_FIELDS, VIDEO_ABUSE_STATES } from '../../initializers/constants'
 
 @Table({
   tableName: 'videoAbuse',
@@ -39,7 +39,7 @@ export class VideoAbuseModel extends Model<VideoAbuseModel> {
 
   @AllowNull(true)
   @Default(null)
-  @Is('VideoAbuseModerationComment', value => throwIfNotValid(value, isVideoAbuseModerationCommentValid, 'moderationComment'))
+  @Is('VideoAbuseModerationComment', value => throwIfNotValid(value, isVideoAbuseModerationCommentValid, 'moderationComment', true))
   @Column(DataType.STRING(CONSTRAINTS_FIELDS.VIDEO_ABUSES.MODERATION_COMMENT.max))
   moderationComment: string
 
diff --git a/server/models/video/video-blacklist.ts b/server/models/video/video-blacklist.ts
index 3b567e488..d9fe9dfc9 100644
--- a/server/models/video/video-blacklist.ts
+++ b/server/models/video/video-blacklist.ts
@@ -1,9 +1,11 @@
-import { AllowNull, BelongsTo, Column, CreatedAt, DataType, ForeignKey, Is, Model, Table, UpdatedAt } from 'sequelize-typescript'
+import { AllowNull, BelongsTo, Column, CreatedAt, DataType, Default, ForeignKey, Is, Model, Table, UpdatedAt } from 'sequelize-typescript'
 import { getSortOnModel, SortType, throwIfNotValid } from '../utils'
 import { VideoModel } from './video'
-import { isVideoBlacklistReasonValid } from '../../helpers/custom-validators/video-blacklist'
-import { VideoBlacklist } from '../../../shared/models/videos'
-import { CONSTRAINTS_FIELDS } from '../../initializers'
+import { ScopeNames as VideoChannelScopeNames, VideoChannelModel } from './video-channel'
+import { isVideoBlacklistReasonValid, isVideoBlacklistTypeValid } from '../../helpers/custom-validators/video-blacklist'
+import { VideoBlacklist, VideoBlacklistType } from '../../../shared/models/videos'
+import { CONSTRAINTS_FIELDS } from '../../initializers/constants'
+import { FindOptions } from 'sequelize'
 
 @Table({
   tableName: 'videoBlacklist',
@@ -17,7 +19,7 @@ import { CONSTRAINTS_FIELDS } from '../../initializers'
 export class VideoBlacklistModel extends Model<VideoBlacklistModel> {
 
   @AllowNull(true)
-  @Is('VideoBlacklistReason', value => throwIfNotValid(value, isVideoBlacklistReasonValid, 'reason'))
+  @Is('VideoBlacklistReason', value => throwIfNotValid(value, isVideoBlacklistReasonValid, 'reason', true))
   @Column(DataType.STRING(CONSTRAINTS_FIELDS.VIDEO_BLACKLIST.REASON.max))
   reason: string
 
@@ -25,6 +27,12 @@ export class VideoBlacklistModel extends Model<VideoBlacklistModel> {
   @Column
   unfederated: boolean
 
+  @AllowNull(false)
+  @Default(null)
+  @Is('VideoBlacklistType', value => throwIfNotValid(value, isVideoBlacklistTypeValid, 'type'))
+  @Column
+  type: VideoBlacklistType
+
   @CreatedAt
   createdAt: Date
 
@@ -43,19 +51,29 @@ export class VideoBlacklistModel extends Model<VideoBlacklistModel> {
   })
   Video: VideoModel
 
-  static listForApi (start: number, count: number, sort: SortType) {
-    const query = {
+  static listForApi (start: number, count: number, sort: SortType, type?: VideoBlacklistType) {
+    const query: FindOptions = {
       offset: start,
       limit: count,
       order: getSortOnModel(sort.sortModel, sort.sortValue),
       include: [
         {
           model: VideoModel,
-          required: true
+          required: true,
+          include: [
+            {
+              model: VideoChannelModel.scope({ method: [ VideoChannelScopeNames.SUMMARY, true ] }),
+              required: true
+            }
+          ]
         }
       ]
     }
 
+    if (type) {
+      query.where = { type }
+    }
+
     return VideoBlacklistModel.findAndCountAll(query)
       .then(({ rows, count }) => {
         return {
@@ -76,26 +94,15 @@ export class VideoBlacklistModel extends Model<VideoBlacklistModel> {
   }
 
   toFormattedJSON (): VideoBlacklist {
-    const video = this.Video
-
     return {
       id: this.id,
       createdAt: this.createdAt,
       updatedAt: this.updatedAt,
       reason: this.reason,
       unfederated: this.unfederated,
+      type: this.type,
 
-      video: {
-        id: video.id,
-        name: video.name,
-        uuid: video.uuid,
-        description: video.description,
-        duration: video.duration,
-        views: video.views,
-        likes: video.likes,
-        dislikes: video.dislikes,
-        nsfw: video.nsfw
-      }
+      video: this.Video.toFormattedJSON()
     }
   }
 }
diff --git a/server/models/video/video-caption.ts b/server/models/video/video-caption.ts
index b4f17b481..76243bf48 100644
--- a/server/models/video/video-caption.ts
+++ b/server/models/video/video-caption.ts
@@ -1,4 +1,4 @@
-import * as Sequelize from 'sequelize'
+import { OrderItem, Transaction } from 'sequelize'
 import {
   AllowNull,
   BeforeDestroy,
@@ -12,30 +12,31 @@ import {
   Table,
   UpdatedAt
 } from 'sequelize-typescript'
-import { throwIfNotValid } from '../utils'
+import { buildWhereIdOrUUID, throwIfNotValid } from '../utils'
 import { VideoModel } from './video'
 import { isVideoCaptionLanguageValid } from '../../helpers/custom-validators/video-captions'
 import { VideoCaption } from '../../../shared/models/videos/caption/video-caption.model'
-import { CONFIG, STATIC_PATHS, VIDEO_LANGUAGES } from '../../initializers'
+import { STATIC_PATHS, VIDEO_LANGUAGES } from '../../initializers/constants'
 import { join } from 'path'
 import { logger } from '../../helpers/logger'
 import { remove } from 'fs-extra'
+import { CONFIG } from '../../initializers/config'
 
 export enum ScopeNames {
   WITH_VIDEO_UUID_AND_REMOTE = 'WITH_VIDEO_UUID_AND_REMOTE'
 }
 
-@Scopes({
+@Scopes(() => ({
   [ScopeNames.WITH_VIDEO_UUID_AND_REMOTE]: {
     include: [
       {
         attributes: [ 'uuid', 'remote' ],
-        model: () => VideoModel.unscoped(),
+        model: VideoModel.unscoped(),
         required: true
       }
     ]
   }
-})
+}))
 
 @Table({
   tableName: 'videoCaption',
@@ -96,12 +97,9 @@ export class VideoCaptionModel extends Model<VideoCaptionModel> {
     const videoInclude = {
       model: VideoModel.unscoped(),
       attributes: [ 'id', 'remote', 'uuid' ],
-      where: { }
+      where: buildWhereIdOrUUID(videoId)
     }
 
-    if (typeof videoId === 'string') videoInclude.where['uuid'] = videoId
-    else videoInclude.where['id'] = videoId
-
     const query = {
       where: {
         language
@@ -114,19 +112,19 @@ export class VideoCaptionModel extends Model<VideoCaptionModel> {
     return VideoCaptionModel.findOne(query)
   }
 
-  static insertOrReplaceLanguage (videoId: number, language: string, transaction: Sequelize.Transaction) {
+  static insertOrReplaceLanguage (videoId: number, language: string, transaction: Transaction) {
     const values = {
       videoId,
       language
     }
 
-    return VideoCaptionModel.upsert<VideoCaptionModel>(values, { transaction, returning: true })
+    return (VideoCaptionModel.upsert<VideoCaptionModel>(values, { transaction, returning: true }) as any) // FIXME: typings
       .then(([ caption ]) => caption)
   }
 
   static listVideoCaptions (videoId: number) {
     const query = {
-      order: [ [ 'language', 'ASC' ] ],
+      order: [ [ 'language', 'ASC' ] ] as OrderItem[],
       where: {
         videoId
       }
@@ -139,7 +137,7 @@ export class VideoCaptionModel extends Model<VideoCaptionModel> {
     return VIDEO_LANGUAGES[language] || 'Unknown'
   }
 
-  static deleteAllCaptionsOfRemoteVideo (videoId: number, transaction: Sequelize.Transaction) {
+  static deleteAllCaptionsOfRemoteVideo (videoId: number, transaction: Transaction) {
     const query = {
       where: {
         videoId
diff --git a/server/models/video/video-change-ownership.ts b/server/models/video/video-change-ownership.ts
index 48c07728f..b545a2f8c 100644
--- a/server/models/video/video-change-ownership.ts
+++ b/server/models/video/video-change-ownership.ts
@@ -1,51 +1,52 @@
 import { AllowNull, BelongsTo, Column, CreatedAt, ForeignKey, Model, Scopes, Table, UpdatedAt } from 'sequelize-typescript'
 import { AccountModel } from '../account/account'
-import { VideoModel } from './video'
+import { ScopeNames as VideoScopeNames, VideoModel } from './video'
 import { VideoChangeOwnership, VideoChangeOwnershipStatus } from '../../../shared/models/videos'
 import { getSort } from '../utils'
-import { VideoFileModel } from './video-file'
 
 enum ScopeNames {
-  FULL = 'FULL'
+  WITH_ACCOUNTS = 'WITH_ACCOUNTS',
+  WITH_VIDEO = 'WITH_VIDEO'
 }
 
 @Table({
   tableName: 'videoChangeOwnership',
   indexes: [
     {
-      fields: ['videoId']
+      fields: [ 'videoId' ]
     },
     {
-      fields: ['initiatorAccountId']
+      fields: [ 'initiatorAccountId' ]
     },
     {
-      fields: ['nextOwnerAccountId']
+      fields: [ 'nextOwnerAccountId' ]
     }
   ]
 })
-@Scopes({
-  [ScopeNames.FULL]: {
+@Scopes(() => ({
+  [ScopeNames.WITH_ACCOUNTS]: {
     include: [
       {
-        model: () => AccountModel,
+        model: AccountModel,
         as: 'Initiator',
         required: true
       },
       {
-        model: () => AccountModel,
+        model: AccountModel,
         as: 'NextOwner',
         required: true
-      },
+      }
+    ]
+  },
+  [ScopeNames.WITH_VIDEO]: {
+    include: [
       {
-        model: () => VideoModel,
-        required: true,
-        include: [
-          { model: () => VideoFileModel }
-        ]
+        model: VideoModel.scope([ VideoScopeNames.WITH_THUMBNAILS, VideoScopeNames.WITH_FILES ]),
+        required: true
       }
     ]
   }
-})
+}))
 export class VideoChangeOwnershipModel extends Model<VideoChangeOwnershipModel> {
   @CreatedAt
   createdAt: Date
@@ -105,12 +106,15 @@ export class VideoChangeOwnershipModel extends Model<VideoChangeOwnershipModel>
       }
     }
 
-    return VideoChangeOwnershipModel.scope(ScopeNames.FULL).findAndCountAll(query)
-                                    .then(({ rows, count }) => ({ total: count, data: rows }))
+    return Promise.all([
+      VideoChangeOwnershipModel.scope(ScopeNames.WITH_ACCOUNTS).count(query),
+      VideoChangeOwnershipModel.scope([ ScopeNames.WITH_ACCOUNTS, ScopeNames.WITH_VIDEO ]).findAll(query)
+    ]).then(([ count, rows ]) => ({ total: count, data: rows }))
   }
 
   static load (id: number) {
-    return VideoChangeOwnershipModel.scope(ScopeNames.FULL).findById(id)
+    return VideoChangeOwnershipModel.scope([ ScopeNames.WITH_ACCOUNTS, ScopeNames.WITH_VIDEO ])
+                                    .findByPk(id)
   }
 
   toFormattedJSON (): VideoChangeOwnership {
diff --git a/server/models/video/video-channel.ts b/server/models/video/video-channel.ts
index 5598d80f6..fb70e6625 100644
--- a/server/models/video/video-channel.ts
+++ b/server/models/video/video-channel.ts
@@ -17,23 +17,25 @@ import {
   UpdatedAt
 } from 'sequelize-typescript'
 import { ActivityPubActor } from '../../../shared/models/activitypub'
-import { VideoChannel } from '../../../shared/models/videos'
+import { VideoChannel, VideoChannelSummary } from '../../../shared/models/videos'
 import {
   isVideoChannelDescriptionValid,
   isVideoChannelNameValid,
   isVideoChannelSupportValid
 } from '../../helpers/custom-validators/video-channels'
 import { sendDeleteActor } from '../../lib/activitypub/send'
-import { AccountModel } from '../account/account'
+import { AccountModel, ScopeNames as AccountModelScopeNames } from '../account/account'
 import { ActorModel, unusedActorAttributesForAPI } from '../activitypub/actor'
-import { buildTrigramSearchIndex, createSimilarityAttribute, getSort, throwIfNotValid } from '../utils'
+import { buildServerIdsFollowedBy, buildTrigramSearchIndex, createSimilarityAttribute, getSort, throwIfNotValid } from '../utils'
 import { VideoModel } from './video'
-import { CONSTRAINTS_FIELDS } from '../../initializers'
+import { CONSTRAINTS_FIELDS, WEBSERVER } from '../../initializers/constants'
 import { ServerModel } from '../server/server'
-import { DefineIndexesOptions } from 'sequelize'
+import { FindOptions, ModelIndexesOptions, Op } from 'sequelize'
+import { AvatarModel } from '../avatar/avatar'
+import { VideoPlaylistModel } from './video-playlist'
 
 // FIXME: Define indexes here because there is an issue with TS and Sequelize.literal when called directly in the annotation
-const indexes: DefineIndexesOptions[] = [
+const indexes: ModelIndexesOptions[] = [
   buildTrigramSearchIndex('video_channel_name_trigram', 'name'),
 
   {
@@ -44,35 +46,62 @@ const indexes: DefineIndexesOptions[] = [
   }
 ]
 
-enum ScopeNames {
+export enum ScopeNames {
   AVAILABLE_FOR_LIST = 'AVAILABLE_FOR_LIST',
   WITH_ACCOUNT = 'WITH_ACCOUNT',
   WITH_ACTOR = 'WITH_ACTOR',
-  WITH_VIDEOS = 'WITH_VIDEOS'
+  WITH_VIDEOS = 'WITH_VIDEOS',
+  SUMMARY = 'SUMMARY'
 }
 
 type AvailableForListOptions = {
   actorId: number
 }
 
-@DefaultScope({
+@DefaultScope(() => ({
   include: [
     {
-      model: () => ActorModel,
+      model: ActorModel,
       required: true
     }
   ]
-})
-@Scopes({
-  [ScopeNames.AVAILABLE_FOR_LIST]: (options: AvailableForListOptions) => {
-    const actorIdNumber = parseInt(options.actorId + '', 10)
+}))
+@Scopes(() => ({
+  [ScopeNames.SUMMARY]: (withAccount = false) => {
+    const base: FindOptions = {
+      attributes: [ 'name', 'description', 'id', 'actorId' ],
+      include: [
+        {
+          attributes: [ 'uuid', 'preferredUsername', 'url', 'serverId', 'avatarId' ],
+          model: ActorModel.unscoped(),
+          required: true,
+          include: [
+            {
+              attributes: [ 'host' ],
+              model: ServerModel.unscoped(),
+              required: false
+            },
+            {
+              model: AvatarModel.unscoped(),
+              required: false
+            }
+          ]
+        }
+      ]
+    }
+
+    if (withAccount === true) {
+      base.include.push({
+        model: AccountModel.scope(AccountModelScopeNames.SUMMARY),
+        required: true
+      })
+    }
 
+    return base
+  },
+  [ScopeNames.AVAILABLE_FOR_LIST]: (options: AvailableForListOptions) => {
     // Only list local channels OR channels that are on an instance followed by actorId
-    const inQueryInstanceFollow = '(' +
-      'SELECT "actor"."serverId" FROM "actorFollow" ' +
-      'INNER JOIN "actor" ON actor.id=  "actorFollow"."targetActorId" ' +
-      'WHERE "actorFollow"."actorId" = ' + actorIdNumber +
-    ')'
+    const inQueryInstanceFollow = buildServerIdsFollowedBy(options.actorId)
 
     return {
       include: [
@@ -82,13 +111,13 @@ type AvailableForListOptions = {
           },
           model: ActorModel,
           where: {
-            [Sequelize.Op.or]: [
+            [Op.or]: [
               {
                 serverId: null
               },
               {
                 serverId: {
-                  [ Sequelize.Op.in ]: Sequelize.literal(inQueryInstanceFollow)
+                  [ Op.in ]: Sequelize.literal(inQueryInstanceFollow)
                 }
               }
             ]
@@ -113,22 +142,22 @@ type AvailableForListOptions = {
   [ScopeNames.WITH_ACCOUNT]: {
     include: [
       {
-        model: () => AccountModel,
+        model: AccountModel,
         required: true
       }
     ]
   },
   [ScopeNames.WITH_VIDEOS]: {
     include: [
-      () => VideoModel
+      VideoModel
     ]
   },
   [ScopeNames.WITH_ACTOR]: {
     include: [
-      () => ActorModel
+      ActorModel
     ]
   }
-})
+}))
 @Table({
   tableName: 'videoChannel',
   indexes
@@ -142,13 +171,13 @@ export class VideoChannelModel extends Model<VideoChannelModel> {
 
   @AllowNull(true)
   @Default(null)
-  @Is('VideoChannelDescription', value => throwIfNotValid(value, isVideoChannelDescriptionValid, 'description'))
+  @Is('VideoChannelDescription', value => throwIfNotValid(value, isVideoChannelDescriptionValid, 'description', true))
   @Column(DataType.STRING(CONSTRAINTS_FIELDS.VIDEO_CHANNELS.DESCRIPTION.max))
   description: string
 
   @AllowNull(true)
   @Default(null)
-  @Is('VideoChannelSupport', value => throwIfNotValid(value, isVideoChannelSupportValid, 'support'))
+  @Is('VideoChannelSupport', value => throwIfNotValid(value, isVideoChannelSupportValid, 'support', true))
   @Column(DataType.STRING(CONSTRAINTS_FIELDS.VIDEO_CHANNELS.SUPPORT.max))
   support: string
 
@@ -192,6 +221,15 @@ export class VideoChannelModel extends Model<VideoChannelModel> {
   })
   Videos: VideoModel[]
 
+  @HasMany(() => VideoPlaylistModel, {
+    foreignKey: {
+      allowNull: true
+    },
+    onDelete: 'CASCADE',
+    hooks: true
+  })
+  VideoPlaylists: VideoPlaylistModel[]
+
   @BeforeDestroy
   static async sendDeleteIfOwned (instance: VideoChannelModel, options) {
     if (!instance.Actor) {
@@ -274,7 +312,7 @@ export class VideoChannelModel extends Model<VideoChannelModel> {
       limit: options.count,
       order: getSort(options.sort),
       where: {
-        [Sequelize.Op.or]: [
+        [Op.or]: [
           Sequelize.literal(
             'lower(immutable_unaccent("VideoChannelModel"."name")) % lower(immutable_unaccent(' + escapedSearch + '))'
           ),
@@ -320,7 +358,7 @@ export class VideoChannelModel extends Model<VideoChannelModel> {
   static loadByIdAndPopulateAccount (id: number) {
     return VideoChannelModel.unscoped()
       .scope([ ScopeNames.WITH_ACTOR, ScopeNames.WITH_ACCOUNT ])
-      .findById(id)
+      .findByPk(id)
   }
 
   static loadByIdAndAccount (id: number, accountId: number) {
@@ -339,7 +377,7 @@ export class VideoChannelModel extends Model<VideoChannelModel> {
   static loadAndPopulateAccount (id: number) {
     return VideoChannelModel.unscoped()
       .scope([ ScopeNames.WITH_ACTOR, ScopeNames.WITH_ACCOUNT ])
-      .findById(id)
+      .findByPk(id)
   }
 
   static loadByUUIDAndPopulateAccount (uuid: string) {
@@ -378,6 +416,14 @@ export class VideoChannelModel extends Model<VideoChannelModel> {
       .findOne(query)
   }
 
+  static loadByNameWithHostAndPopulateAccount (nameWithHost: string) {
+    const [ name, host ] = nameWithHost.split('@')
+
+    if (!host || host === WEBSERVER.HOST) return VideoChannelModel.loadLocalByNameAndPopulateAccount(name)
+
+    return VideoChannelModel.loadByNameAndHostAndPopulateAccount(name, host)
+  }
+
   static loadLocalByNameAndPopulateAccount (name: string) {
     const query = {
       include: [
@@ -431,7 +477,7 @@ export class VideoChannelModel extends Model<VideoChannelModel> {
 
     return VideoChannelModel.unscoped()
       .scope([ ScopeNames.WITH_ACTOR, ScopeNames.WITH_ACCOUNT, ScopeNames.WITH_VIDEOS ])
-      .findById(id, options)
+      .findByPk(id, options)
   }
 
   toFormattedJSON (): VideoChannel {
@@ -452,6 +498,20 @@ export class VideoChannelModel extends Model<VideoChannelModel> {
     return Object.assign(actor, videoChannel)
   }
 
+  toFormattedSummaryJSON (): VideoChannelSummary {
+    const actor = this.Actor.toFormattedJSON()
+
+    return {
+      id: this.id,
+      uuid: actor.uuid,
+      name: actor.name,
+      displayName: this.getDisplayName(),
+      url: actor.url,
+      host: actor.host,
+      avatar: actor.avatar
+    }
+  }
+
   toActivityPubObject (): ActivityPubActor {
     const obj = this.Actor.toActivityPubObject(this.name, 'VideoChannel')
 
diff --git a/server/models/video/video-comment.ts b/server/models/video/video-comment.ts
index 1163f9a0e..fee11ec5f 100644
--- a/server/models/video/video-comment.ts
+++ b/server/models/video/video-comment.ts
@@ -1,4 +1,3 @@
-import * as Sequelize from 'sequelize'
 import {
   AllowNull,
   BeforeDestroy,
@@ -7,7 +6,6 @@ import {
   CreatedAt,
   DataType,
   ForeignKey,
-  IFindOptions,
   Is,
   Model,
   Scopes,
@@ -18,7 +16,7 @@ import { ActivityTagObject } from '../../../shared/models/activitypub/objects/co
 import { VideoCommentObject } from '../../../shared/models/activitypub/objects/video-comment-object'
 import { VideoComment } from '../../../shared/models/videos/video-comment.model'
 import { isActivityPubUrlValid } from '../../helpers/custom-validators/activitypub/misc'
-import { CONFIG, CONSTRAINTS_FIELDS } from '../../initializers'
+import { CONSTRAINTS_FIELDS, WEBSERVER } from '../../initializers/constants'
 import { sendDeleteVideoComment } from '../../lib/activitypub/send'
 import { AccountModel } from '../account/account'
 import { ActorModel } from '../activitypub/actor'
@@ -32,6 +30,7 @@ import { UserModel } from '../account/user'
 import { actorNameAlphabet } from '../../helpers/custom-validators/activitypub/actor'
 import { regexpCapture } from '../../helpers/regexp'
 import { uniq } from 'lodash'
+import { FindOptions, Op, Order, ScopeOptions, Sequelize, Transaction } from 'sequelize'
 
 enum ScopeNames {
   WITH_ACCOUNT = 'WITH_ACCOUNT',
@@ -40,7 +39,7 @@ enum ScopeNames {
   ATTRIBUTES_FOR_API = 'ATTRIBUTES_FOR_API'
 }
 
-@Scopes({
+@Scopes(() => ({
   [ScopeNames.ATTRIBUTES_FOR_API]: (serverAccountId: number, userAccountId?: number) => {
     return {
       attributes: {
@@ -64,22 +63,22 @@ enum ScopeNames {
           ]
         ]
       }
-    }
+    } as FindOptions
   },
   [ScopeNames.WITH_ACCOUNT]: {
     include: [
       {
-        model: () => AccountModel,
+        model: AccountModel,
         include: [
           {
-            model: () => ActorModel,
+            model: ActorModel,
             include: [
               {
-                model: () => ServerModel,
+                model: ServerModel,
                 required: false
               },
               {
-                model: () => AvatarModel,
+                model: AvatarModel,
                 required: false
               }
             ]
@@ -91,7 +90,7 @@ enum ScopeNames {
   [ScopeNames.WITH_IN_REPLY_TO]: {
     include: [
       {
-        model: () => VideoCommentModel,
+        model: VideoCommentModel,
         as: 'InReplyToVideoComment'
       }
     ]
@@ -99,19 +98,19 @@ enum ScopeNames {
   [ScopeNames.WITH_VIDEO]: {
     include: [
       {
-        model: () => VideoModel,
+        model: VideoModel,
         required: true,
         include: [
           {
-            model: () => VideoChannelModel.unscoped(),
+            model: VideoChannelModel.unscoped(),
             required: true,
             include: [
               {
-                model: () => AccountModel,
+                model: AccountModel,
                 required: true,
                 include: [
                   {
-                    model: () => ActorModel,
+                    model: ActorModel,
                     required: true
                   }
                 ]
@@ -122,7 +121,7 @@ enum ScopeNames {
       }
     ]
   }
-})
+}))
 @Table({
   tableName: 'videoComment',
   indexes: [
@@ -244,8 +243,8 @@ export class VideoCommentModel extends Model<VideoCommentModel> {
     }
   }
 
-  static loadById (id: number, t?: Sequelize.Transaction) {
-    const query: IFindOptions<VideoCommentModel> = {
+  static loadById (id: number, t?: Transaction) {
+    const query: FindOptions = {
       where: {
         id
       }
@@ -256,8 +255,8 @@ export class VideoCommentModel extends Model<VideoCommentModel> {
     return VideoCommentModel.findOne(query)
   }
 
-  static loadByIdAndPopulateVideoAndAccountAndReply (id: number, t?: Sequelize.Transaction) {
-    const query: IFindOptions<VideoCommentModel> = {
+  static loadByIdAndPopulateVideoAndAccountAndReply (id: number, t?: Transaction) {
+    const query: FindOptions = {
       where: {
         id
       }
@@ -270,8 +269,8 @@ export class VideoCommentModel extends Model<VideoCommentModel> {
       .findOne(query)
   }
 
-  static loadByUrlAndPopulateAccount (url: string, t?: Sequelize.Transaction) {
-    const query: IFindOptions<VideoCommentModel> = {
+  static loadByUrlAndPopulateAccount (url: string, t?: Transaction) {
+    const query: FindOptions = {
       where: {
         url
       }
@@ -282,8 +281,8 @@ export class VideoCommentModel extends Model<VideoCommentModel> {
     return VideoCommentModel.scope([ ScopeNames.WITH_ACCOUNT ]).findOne(query)
   }
 
-  static loadByUrlAndPopulateReplyAndVideo (url: string, t?: Sequelize.Transaction) {
-    const query: IFindOptions<VideoCommentModel> = {
+  static loadByUrlAndPopulateReplyAndVideo (url: string, t?: Transaction) {
+    const query: FindOptions = {
       where: {
         url
       }
@@ -307,15 +306,14 @@ export class VideoCommentModel extends Model<VideoCommentModel> {
         videoId,
         inReplyToCommentId: null,
         accountId: {
-          [Sequelize.Op.notIn]: Sequelize.literal(
+          [Op.notIn]: Sequelize.literal(
             '(' + buildBlockedAccountSQL(serverAccountId, userAccountId) + ')'
           )
         }
       }
     }
 
-    // FIXME: typings
-    const scopes: any[] = [
+    const scopes: (string | ScopeOptions)[] = [
       ScopeNames.WITH_ACCOUNT,
       {
         method: [ ScopeNames.ATTRIBUTES_FOR_API, serverAccountId, userAccountId ]
@@ -336,15 +334,15 @@ export class VideoCommentModel extends Model<VideoCommentModel> {
     const userAccountId = user ? user.Account.id : undefined
 
     const query = {
-      order: [ [ 'createdAt', 'ASC' ], [ 'updatedAt', 'ASC' ] ],
+      order: [ [ 'createdAt', 'ASC' ], [ 'updatedAt', 'ASC' ] ] as Order,
       where: {
         videoId,
-        [ Sequelize.Op.or ]: [
+        [ Op.or ]: [
           { id: threadId },
           { originCommentId: threadId }
         ],
         accountId: {
-          [Sequelize.Op.notIn]: Sequelize.literal(
+          [Op.notIn]: Sequelize.literal(
             '(' + buildBlockedAccountSQL(serverAccountId, userAccountId) + ')'
           )
         }
@@ -366,12 +364,12 @@ export class VideoCommentModel extends Model<VideoCommentModel> {
       })
   }
 
-  static listThreadParentComments (comment: VideoCommentModel, t: Sequelize.Transaction, order: 'ASC' | 'DESC' = 'ASC') {
+  static listThreadParentComments (comment: VideoCommentModel, t: Transaction, order: 'ASC' | 'DESC' = 'ASC') {
     const query = {
-      order: [ [ 'createdAt', order ] ],
+      order: [ [ 'createdAt', order ] ] as Order,
       where: {
         id: {
-          [ Sequelize.Op.in ]: Sequelize.literal('(' +
+          [ Op.in ]: Sequelize.literal('(' +
             'WITH RECURSIVE children (id, "inReplyToCommentId") AS ( ' +
               `SELECT id, "inReplyToCommentId" FROM "videoComment" WHERE id = ${comment.id} ` +
               'UNION ' +
@@ -380,7 +378,7 @@ export class VideoCommentModel extends Model<VideoCommentModel> {
             ') ' +
             'SELECT id FROM children' +
           ')'),
-          [ Sequelize.Op.ne ]: comment.id
+          [ Op.ne ]: comment.id
         }
       },
       transaction: t
@@ -391,9 +389,9 @@ export class VideoCommentModel extends Model<VideoCommentModel> {
       .findAll(query)
   }
 
-  static listAndCountByVideoId (videoId: number, start: number, count: number, t?: Sequelize.Transaction, order: 'ASC' | 'DESC' = 'ASC') {
+  static listAndCountByVideoId (videoId: number, start: number, count: number, t?: Transaction, order: 'ASC' | 'DESC' = 'ASC') {
     const query = {
-      order: [ [ 'createdAt', order ] ],
+      order: [ [ 'createdAt', order ] ] as Order,
       offset: start,
       limit: count,
       where: {
@@ -407,7 +405,7 @@ export class VideoCommentModel extends Model<VideoCommentModel> {
 
   static listForFeed (start: number, count: number, videoId?: number) {
     const query = {
-      order: [ [ 'createdAt', 'DESC' ] ],
+      order: [ [ 'createdAt', 'DESC' ] ] as Order,
       offset: start,
       limit: count,
       where: {},
@@ -453,6 +451,19 @@ export class VideoCommentModel extends Model<VideoCommentModel> {
     }
   }
 
+  static cleanOldCommentsOf (videoId: number, beforeUpdatedAt: Date) {
+    const query = {
+      where: {
+        updatedAt: {
+          [Op.lt]: beforeUpdatedAt
+        },
+        videoId
+      }
+    }
+
+    return VideoCommentModel.destroy(query)
+  }
+
   getCommentStaticPath () {
     return this.Video.getWatchStaticPath() + ';threadId=' + this.getThreadId()
   }
@@ -469,7 +480,7 @@ export class VideoCommentModel extends Model<VideoCommentModel> {
     let result: string[] = []
 
     const localMention = `@(${actorNameAlphabet}+)`
-    const remoteMention = `${localMention}@${CONFIG.WEBSERVER.HOST}`
+    const remoteMention = `${localMention}@${WEBSERVER.HOST}`
 
     const mentionRegex = this.isOwned()
       ? '(?:(?:' + remoteMention + ')|(?:' + localMention + '))' // Include local mentions?
diff --git a/server/models/video/video-file.ts b/server/models/video/video-file.ts
index 1f1b76c1e..2203a7aba 100644
--- a/server/models/video/video-file.ts
+++ b/server/models/video/video-file.ts
@@ -19,10 +19,11 @@ import {
   isVideoFileSizeValid,
   isVideoFPSResolutionValid
 } from '../../helpers/custom-validators/videos'
-import { throwIfNotValid } from '../utils'
+import { parseAggregateResult, throwIfNotValid } from '../utils'
 import { VideoModel } from './video'
-import * as Sequelize from 'sequelize'
 import { VideoRedundancyModel } from '../redundancy/video-redundancy'
+import { VideoStreamingPlaylistModel } from './video-streaming-playlist'
+import { FindOptions, QueryTypes, Transaction } from 'sequelize'
 
 @Table({
   tableName: 'videoFile',
@@ -62,7 +63,7 @@ export class VideoFileModel extends Model<VideoFileModel> {
   extname: string
 
   @AllowNull(false)
-  @Is('VideoFileSize', value => throwIfNotValid(value, isVideoFileInfoHashValid, 'info hash'))
+  @Is('VideoFileInfohash', value => throwIfNotValid(value, isVideoFileInfoHashValid, 'info hash'))
   @Column
   infoHash: string
 
@@ -86,25 +87,23 @@ export class VideoFileModel extends Model<VideoFileModel> {
 
   @HasMany(() => VideoRedundancyModel, {
     foreignKey: {
-      allowNull: false
+      allowNull: true
     },
     onDelete: 'CASCADE',
     hooks: true
   })
   RedundancyVideos: VideoRedundancyModel[]
 
-  static isInfohashExists (infoHash: string) {
+  static doesInfohashExist (infoHash: string) {
     const query = 'SELECT 1 FROM "videoFile" WHERE "infoHash" = $infoHash LIMIT 1'
     const options = {
-      type: Sequelize.QueryTypes.SELECT,
+      type: QueryTypes.SELECT,
       bind: { infoHash },
       raw: true
     }
 
     return VideoModel.sequelize.query(query, options)
-              .then(results => {
-                return results.length === 1
-              })
+              .then(results => results.length === 1)
   }
 
   static loadWithVideo (id: number) {
@@ -117,11 +116,34 @@ export class VideoFileModel extends Model<VideoFileModel> {
       ]
     }
 
-    return VideoFileModel.findById(id, options)
+    return VideoFileModel.findByPk(id, options)
   }
 
-  static async getStats () {
-    let totalLocalVideoFilesSize = await VideoFileModel.sum('size', {
+  static listByStreamingPlaylist (streamingPlaylistId: number, transaction: Transaction) {
+    const query = {
+      include: [
+        {
+          model: VideoModel.unscoped(),
+          required: true,
+          include: [
+            {
+              model: VideoStreamingPlaylistModel.unscoped(),
+              required: true,
+              where: {
+                id: streamingPlaylistId
+              }
+            }
+          ]
+        }
+      ],
+      transaction
+    }
+
+    return VideoFileModel.findAll(query)
+  }
+
+  static getStats () {
+    const query: FindOptions = {
       include: [
         {
           attributes: [],
@@ -131,13 +153,12 @@ export class VideoFileModel extends Model<VideoFileModel> {
           }
         }
       ]
-    } as any)
-    // Sequelize could return null...
-    if (!totalLocalVideoFilesSize) totalLocalVideoFilesSize = 0
-
-    return {
-      totalLocalVideoFilesSize
     }
+
+    return VideoFileModel.aggregate('size', 'SUM', query)
+      .then(result => ({
+        totalLocalVideoFilesSize: parseAggregateResult(result)
+      }))
   }
 
   hasSameUniqueKeysThan (other: VideoFileModel) {
diff --git a/server/models/video/video-format-utils.ts b/server/models/video/video-format-utils.ts
index de0747f22..b947eb16f 100644
--- a/server/models/video/video-format-utils.ts
+++ b/server/models/video/video-format-utils.ts
@@ -1,8 +1,13 @@
 import { Video, VideoDetails, VideoFile } from '../../../shared/models/videos'
 import { VideoModel } from './video'
 import { VideoFileModel } from './video-file'
-import { ActivityUrlObject, VideoTorrentObject } from '../../../shared/models/activitypub/objects'
-import { CONFIG, MIMETYPES, THUMBNAILS_SIZE } from '../../initializers'
+import {
+  ActivityPlaylistInfohashesObject,
+  ActivityPlaylistSegmentHashesObject,
+  ActivityUrlObject,
+  VideoTorrentObject
+} from '../../../shared/models/activitypub/objects'
+import { MIMETYPES, WEBSERVER } from '../../initializers/constants'
 import { VideoCaptionModel } from './video-caption'
 import {
   getVideoCommentsActivityPubUrl,
@@ -11,6 +16,8 @@ import {
   getVideoSharesActivityPubUrl
 } from '../../lib/activitypub'
 import { isArray } from '../../helpers/custom-validators/misc'
+import { VideoStreamingPlaylist } from '../../../shared/models/videos/video-streaming-playlist.model'
+import { VideoStreamingPlaylistModel } from './video-streaming-playlist'
 
 export type VideoFormattingJSONOptions = {
   completeDescription?: boolean
@@ -19,12 +26,10 @@ export type VideoFormattingJSONOptions = {
     waitTranscoding?: boolean,
     scheduledUpdate?: boolean,
     blacklistInfo?: boolean
+    playlistInfo?: boolean
   }
 }
 function videoModelToFormattedJSON (video: VideoModel, options?: VideoFormattingJSONOptions): Video {
-  const formattedAccount = video.VideoChannel.Account.toFormattedJSON()
-  const formattedVideoChannel = video.VideoChannel.toFormattedJSON()
-
   const userHistory = isArray(video.UserVideoHistories) ? video.UserVideoHistories[0] : undefined
 
   const videoObject: Video = {
@@ -54,30 +59,16 @@ function videoModelToFormattedJSON (video: VideoModel, options?: VideoFormatting
     views: video.views,
     likes: video.likes,
     dislikes: video.dislikes,
-    thumbnailPath: video.getThumbnailStaticPath(),
+    thumbnailPath: video.getMiniatureStaticPath(),
     previewPath: video.getPreviewStaticPath(),
     embedPath: video.getEmbedStaticPath(),
     createdAt: video.createdAt,
     updatedAt: video.updatedAt,
     publishedAt: video.publishedAt,
-    account: {
-      id: formattedAccount.id,
-      uuid: formattedAccount.uuid,
-      name: formattedAccount.name,
-      displayName: formattedAccount.displayName,
-      url: formattedAccount.url,
-      host: formattedAccount.host,
-      avatar: formattedAccount.avatar
-    },
-    channel: {
-      id: formattedVideoChannel.id,
-      uuid: formattedVideoChannel.uuid,
-      name: formattedVideoChannel.name,
-      displayName: formattedVideoChannel.displayName,
-      url: formattedVideoChannel.url,
-      host: formattedVideoChannel.host,
-      avatar: formattedVideoChannel.avatar
-    },
+    originallyPublishedAt: video.originallyPublishedAt,
+
+    account: video.VideoChannel.Account.toFormattedSummaryJSON(),
+    channel: video.VideoChannel.toFormattedSummaryJSON(),
 
     userHistory: userHistory ? {
       currentTime: userHistory.currentTime
@@ -107,6 +98,17 @@ function videoModelToFormattedJSON (video: VideoModel, options?: VideoFormatting
       videoObject.blacklisted = !!video.VideoBlacklist
       videoObject.blacklistedReason = video.VideoBlacklist ? video.VideoBlacklist.reason : null
     }
+
+    if (options.additionalAttributes.playlistInfo === true) {
+      // We filtered on a specific videoId/videoPlaylistId, that is unique
+      const playlistElement = video.VideoPlaylistElements[0]
+
+      videoObject.playlistElement = {
+        position: playlistElement.position,
+        startTimestamp: playlistElement.startTimestamp,
+        stopTimestamp: playlistElement.stopTimestamp
+      }
+    }
   }
 
   return videoObject
@@ -120,7 +122,12 @@ function videoModelToFormattedDetailsJSON (video: VideoModel): VideoDetails {
     }
   })
 
+  const { baseUrlHttp, baseUrlWs } = video.getBaseUrls()
+
   const tags = video.Tags ? video.Tags.map(t => t.name) : []
+
+  const streamingPlaylists = streamingPlaylistsModelToFormattedJSON(video, video.VideoStreamingPlaylists)
+
   const detailsJson = {
     support: video.support,
     descriptionPath: video.getDescriptionAPIPath(),
@@ -128,12 +135,17 @@ function videoModelToFormattedDetailsJSON (video: VideoModel): VideoDetails {
     account: video.VideoChannel.Account.toFormattedJSON(),
     tags,
     commentsEnabled: video.commentsEnabled,
+    downloadEnabled: video.downloadEnabled,
     waitTranscoding: video.waitTranscoding,
     state: {
       id: video.state,
       label: VideoModel.getStateLabel(video.state)
     },
-    files: []
+
+    trackerUrls: video.getTrackerUrls(baseUrlHttp, baseUrlWs),
+
+    files: [],
+    streamingPlaylists
   }
 
   // Format and sort video files
@@ -142,6 +154,25 @@ function videoModelToFormattedDetailsJSON (video: VideoModel): VideoDetails {
   return Object.assign(formattedJson, detailsJson)
 }
 
+function streamingPlaylistsModelToFormattedJSON (video: VideoModel, playlists: VideoStreamingPlaylistModel[]): VideoStreamingPlaylist[] {
+  if (isArray(playlists) === false) return []
+
+  return playlists
+    .map(playlist => {
+      const redundancies = isArray(playlist.RedundancyVideos)
+        ? playlist.RedundancyVideos.map(r => ({ baseUrl: r.fileUrl }))
+        : []
+
+      return {
+        id: playlist.id,
+        type: playlist.type,
+        playlistUrl: playlist.playlistUrl,
+        segmentsSha256Url: playlist.segmentsSha256Url,
+        redundancies
+      } as VideoStreamingPlaylist
+    })
+}
+
 function videoFilesModelToFormattedJSON (video: VideoModel, videoFiles: VideoFileModel[]): VideoFile[] {
   const { baseUrlHttp, baseUrlWs } = video.getBaseUrls()
 
@@ -232,12 +263,34 @@ function videoModelToActivityPubObject (video: VideoModel): VideoTorrentObject {
     })
   }
 
+  for (const playlist of (video.VideoStreamingPlaylists || [])) {
+    let tag: (ActivityPlaylistSegmentHashesObject | ActivityPlaylistInfohashesObject)[]
+
+    tag = playlist.p2pMediaLoaderInfohashes
+                  .map(i => ({ type: 'Infohash' as 'Infohash', name: i }))
+    tag.push({
+      type: 'Link',
+      name: 'sha256',
+      mimeType: 'application/json' as 'application/json',
+      mediaType: 'application/json' as 'application/json',
+      href: playlist.segmentsSha256Url
+    })
+
+    url.push({
+      type: 'Link',
+      mimeType: 'application/x-mpegURL' as 'application/x-mpegURL',
+      mediaType: 'application/x-mpegURL' as 'application/x-mpegURL',
+      href: playlist.playlistUrl,
+      tag
+    })
+  }
+
   // Add video url too
   url.push({
     type: 'Link',
     mimeType: 'text/html',
     mediaType: 'text/html',
-    href: CONFIG.WEBSERVER.URL + '/videos/watch/' + video.uuid
+    href: WEBSERVER.URL + '/videos/watch/' + video.uuid
   })
 
   const subtitleLanguage = []
@@ -248,6 +301,8 @@ function videoModelToActivityPubObject (video: VideoModel): VideoTorrentObject {
     })
   }
 
+  const miniature = video.getMiniature()
+
   return {
     type: 'Video' as 'Video',
     id: video.url,
@@ -263,7 +318,9 @@ function videoModelToActivityPubObject (video: VideoModel): VideoTorrentObject {
     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.getTruncatedDescription(),
@@ -271,10 +328,10 @@ function videoModelToActivityPubObject (video: VideoModel): VideoTorrentObject {
     subtitleLanguage,
     icon: {
       type: 'Image',
-      url: video.getThumbnailUrl(baseUrlHttp),
+      url: miniature.getFileUrl(),
       mediaType: 'image/jpeg',
-      width: THUMBNAILS_SIZE.width,
-      height: THUMBNAILS_SIZE.height
+      width: miniature.width,
+      height: miniature.height
     },
     url,
     likes: getVideoLikesActivityPubUrl(video),
diff --git a/server/models/video/video-import.ts b/server/models/video/video-import.ts
index c723e57c0..480a671c8 100644
--- a/server/models/video/video-import.ts
+++ b/server/models/video/video-import.ts
@@ -13,7 +13,7 @@ import {
   Table,
   UpdatedAt
 } from 'sequelize-typescript'
-import { CONSTRAINTS_FIELDS, VIDEO_IMPORT_STATES } from '../../initializers'
+import { CONSTRAINTS_FIELDS, VIDEO_IMPORT_STATES } from '../../initializers/constants'
 import { getSort, throwIfNotValid } from '../utils'
 import { ScopeNames as VideoModelScopeNames, VideoModel } from './video'
 import { isVideoImportStateValid, isVideoImportTargetUrlValid } from '../../helpers/custom-validators/video-imports'
@@ -21,18 +21,18 @@ import { VideoImport, VideoImportState } from '../../../shared'
 import { isVideoMagnetUriValid } from '../../helpers/custom-validators/videos'
 import { UserModel } from '../account/user'
 
-@DefaultScope({
+@DefaultScope(() => ({
   include: [
     {
-      model: () => UserModel.unscoped(),
+      model: UserModel.unscoped(),
       required: true
     },
     {
-      model: () => VideoModel.scope([ VideoModelScopeNames.WITH_ACCOUNT_DETAILS, VideoModelScopeNames.WITH_TAGS]),
+      model: VideoModel.scope([ VideoModelScopeNames.WITH_ACCOUNT_DETAILS, VideoModelScopeNames.WITH_TAGS]),
       required: false
     }
   ]
-})
+}))
 
 @Table({
   tableName: 'videoImport',
@@ -55,13 +55,13 @@ export class VideoImportModel extends Model<VideoImportModel> {
 
   @AllowNull(true)
   @Default(null)
-  @Is('VideoImportTargetUrl', value => throwIfNotValid(value, isVideoImportTargetUrlValid, 'targetUrl'))
+  @Is('VideoImportTargetUrl', value => throwIfNotValid(value, isVideoImportTargetUrlValid, 'targetUrl', true))
   @Column(DataType.STRING(CONSTRAINTS_FIELDS.VIDEO_IMPORTS.URL.max))
   targetUrl: string
 
   @AllowNull(true)
   @Default(null)
-  @Is('VideoImportMagnetUri', value => throwIfNotValid(value, isVideoMagnetUriValid, 'magnetUri'))
+  @Is('VideoImportMagnetUri', value => throwIfNotValid(value, isVideoMagnetUriValid, 'magnetUri', true))
   @Column(DataType.STRING(CONSTRAINTS_FIELDS.VIDEO_IMPORTS.URL.max)) // Use the same constraints than URLs
   magnetUri: string
 
@@ -115,7 +115,7 @@ export class VideoImportModel extends Model<VideoImportModel> {
   }
 
   static loadAndPopulateVideo (id: number) {
-    return VideoImportModel.findById(id)
+    return VideoImportModel.findByPk(id)
   }
 
   static listUserVideoImportsForApi (userId: number, start: number, count: number, sort: string) {
diff --git a/server/models/video/video-playlist-element.ts b/server/models/video/video-playlist-element.ts
new file mode 100644
index 000000000..eeb3d6bbd
--- /dev/null
+++ b/server/models/video/video-playlist-element.ts
@@ -0,0 +1,230 @@
+import {
+  AllowNull,
+  BelongsTo,
+  Column,
+  CreatedAt,
+  DataType,
+  Default,
+  ForeignKey,
+  Is,
+  IsInt,
+  Min,
+  Model,
+  Table,
+  UpdatedAt
+} from 'sequelize-typescript'
+import { VideoModel } from './video'
+import { VideoPlaylistModel } from './video-playlist'
+import { getSort, throwIfNotValid } from '../utils'
+import { isActivityPubUrlValid } from '../../helpers/custom-validators/activitypub/misc'
+import { CONSTRAINTS_FIELDS } from '../../initializers/constants'
+import { PlaylistElementObject } from '../../../shared/models/activitypub/objects/playlist-element-object'
+import * as validator from 'validator'
+import { AggregateOptions, Op, Sequelize, Transaction } from 'sequelize'
+
+@Table({
+  tableName: 'videoPlaylistElement',
+  indexes: [
+    {
+      fields: [ 'videoPlaylistId' ]
+    },
+    {
+      fields: [ 'videoId' ]
+    },
+    {
+      fields: [ 'videoPlaylistId', 'videoId' ],
+      unique: true
+    },
+    {
+      fields: [ 'url' ],
+      unique: true
+    }
+  ]
+})
+export class VideoPlaylistElementModel extends Model<VideoPlaylistElementModel> {
+  @CreatedAt
+  createdAt: Date
+
+  @UpdatedAt
+  updatedAt: Date
+
+  @AllowNull(false)
+  @Is('VideoPlaylistUrl', value => throwIfNotValid(value, isActivityPubUrlValid, 'url'))
+  @Column(DataType.STRING(CONSTRAINTS_FIELDS.VIDEO_PLAYLISTS.URL.max))
+  url: string
+
+  @AllowNull(false)
+  @Default(1)
+  @IsInt
+  @Min(1)
+  @Column
+  position: number
+
+  @AllowNull(true)
+  @IsInt
+  @Min(0)
+  @Column
+  startTimestamp: number
+
+  @AllowNull(true)
+  @IsInt
+  @Min(0)
+  @Column
+  stopTimestamp: number
+
+  @ForeignKey(() => VideoPlaylistModel)
+  @Column
+  videoPlaylistId: number
+
+  @BelongsTo(() => VideoPlaylistModel, {
+    foreignKey: {
+      allowNull: false
+    },
+    onDelete: 'CASCADE'
+  })
+  VideoPlaylist: VideoPlaylistModel
+
+  @ForeignKey(() => VideoModel)
+  @Column
+  videoId: number
+
+  @BelongsTo(() => VideoModel, {
+    foreignKey: {
+      allowNull: false
+    },
+    onDelete: 'CASCADE'
+  })
+  Video: VideoModel
+
+  static deleteAllOf (videoPlaylistId: number, transaction?: Transaction) {
+    const query = {
+      where: {
+        videoPlaylistId
+      },
+      transaction
+    }
+
+    return VideoPlaylistElementModel.destroy(query)
+  }
+
+  static loadByPlaylistAndVideo (videoPlaylistId: number, videoId: number) {
+    const query = {
+      where: {
+        videoPlaylistId,
+        videoId
+      }
+    }
+
+    return VideoPlaylistElementModel.findOne(query)
+  }
+
+  static loadByPlaylistAndVideoForAP (playlistId: number | string, videoId: number | string) {
+    const playlistWhere = validator.isUUID('' + playlistId) ? { uuid: playlistId } : { id: playlistId }
+    const videoWhere = validator.isUUID('' + videoId) ? { uuid: videoId } : { id: videoId }
+
+    const query = {
+      include: [
+        {
+          attributes: [ 'privacy' ],
+          model: VideoPlaylistModel.unscoped(),
+          where: playlistWhere
+        },
+        {
+          attributes: [ 'url' ],
+          model: VideoModel.unscoped(),
+          where: videoWhere
+        }
+      ]
+    }
+
+    return VideoPlaylistElementModel.findOne(query)
+  }
+
+  static listUrlsOfForAP (videoPlaylistId: number, start: number, count: number, t?: Transaction) {
+    const query = {
+      attributes: [ 'url' ],
+      offset: start,
+      limit: count,
+      order: getSort('position'),
+      where: {
+        videoPlaylistId
+      },
+      transaction: t
+    }
+
+    return VideoPlaylistElementModel
+      .findAndCountAll(query)
+      .then(({ rows, count }) => {
+        return { total: count, data: rows.map(e => e.url) }
+      })
+  }
+
+  static getNextPositionOf (videoPlaylistId: number, transaction?: Transaction) {
+    const query: AggregateOptions<number> = {
+      where: {
+        videoPlaylistId
+      },
+      transaction
+    }
+
+    return VideoPlaylistElementModel.max('position', query)
+      .then(position => position ? position + 1 : 1)
+  }
+
+  static reassignPositionOf (
+    videoPlaylistId: number,
+    firstPosition: number,
+    endPosition: number,
+    newPosition: number,
+    transaction?: Transaction
+  ) {
+    const query = {
+      where: {
+        videoPlaylistId,
+        position: {
+          [Op.gte]: firstPosition,
+          [Op.lte]: endPosition
+        }
+      },
+      transaction,
+      validate: false // We use a literal to update the position
+    }
+
+    return VideoPlaylistElementModel.update({ position: Sequelize.literal(`${newPosition} + "position" - ${firstPosition}`) }, query)
+  }
+
+  static increasePositionOf (
+    videoPlaylistId: number,
+    fromPosition: number,
+    toPosition?: number,
+    by = 1,
+    transaction?: Transaction
+  ) {
+    const query = {
+      where: {
+        videoPlaylistId,
+        position: {
+          [Op.gte]: fromPosition
+        }
+      },
+      transaction
+    }
+
+    return VideoPlaylistElementModel.increment({ position: by }, query)
+  }
+
+  toActivityPubObject (): PlaylistElementObject {
+    const base: PlaylistElementObject = {
+      id: this.url,
+      type: 'PlaylistElement',
+
+      url: this.Video.url,
+      position: this.position
+    }
+
+    if (this.startTimestamp) base.startTimestamp = this.startTimestamp
+    if (this.stopTimestamp) base.stopTimestamp = this.stopTimestamp
+
+    return base
+  }
+}
diff --git a/server/models/video/video-playlist.ts b/server/models/video/video-playlist.ts
new file mode 100644
index 000000000..63b4a0715
--- /dev/null
+++ b/server/models/video/video-playlist.ts
@@ -0,0 +1,531 @@
+import {
+  AllowNull,
+  BelongsTo,
+  Column,
+  CreatedAt,
+  DataType,
+  Default,
+  ForeignKey,
+  HasMany,
+  HasOne,
+  Is,
+  IsUUID,
+  Model,
+  Scopes,
+  Table,
+  UpdatedAt
+} from 'sequelize-typescript'
+import { VideoPlaylistPrivacy } from '../../../shared/models/videos/playlist/video-playlist-privacy.model'
+import { buildServerIdsFollowedBy, buildWhereIdOrUUID, getSort, isOutdated, throwIfNotValid } from '../utils'
+import {
+  isVideoPlaylistDescriptionValid,
+  isVideoPlaylistNameValid,
+  isVideoPlaylistPrivacyValid
+} from '../../helpers/custom-validators/video-playlists'
+import { isActivityPubUrlValid } from '../../helpers/custom-validators/activitypub/misc'
+import {
+  ACTIVITY_PUB,
+  CONSTRAINTS_FIELDS,
+  STATIC_PATHS,
+  THUMBNAILS_SIZE,
+  VIDEO_PLAYLIST_PRIVACIES,
+  VIDEO_PLAYLIST_TYPES,
+  WEBSERVER
+} from '../../initializers/constants'
+import { VideoPlaylist } from '../../../shared/models/videos/playlist/video-playlist.model'
+import { AccountModel, ScopeNames as AccountScopeNames } from '../account/account'
+import { ScopeNames as VideoChannelScopeNames, VideoChannelModel } from './video-channel'
+import { join } from 'path'
+import { VideoPlaylistElementModel } from './video-playlist-element'
+import { PlaylistObject } from '../../../shared/models/activitypub/objects/playlist-object'
+import { activityPubCollectionPagination } from '../../helpers/activitypub'
+import { VideoPlaylistType } from '../../../shared/models/videos/playlist/video-playlist-type.model'
+import { ThumbnailModel } from './thumbnail'
+import { ActivityIconObject } from '../../../shared/models/activitypub/objects'
+import { FindOptions, literal, Op, ScopeOptions, Transaction, WhereOptions } from 'sequelize'
+
+enum ScopeNames {
+  AVAILABLE_FOR_LIST = 'AVAILABLE_FOR_LIST',
+  WITH_VIDEOS_LENGTH = 'WITH_VIDEOS_LENGTH',
+  WITH_ACCOUNT_AND_CHANNEL_SUMMARY = 'WITH_ACCOUNT_AND_CHANNEL_SUMMARY',
+  WITH_ACCOUNT = 'WITH_ACCOUNT',
+  WITH_THUMBNAIL = 'WITH_THUMBNAIL',
+  WITH_ACCOUNT_AND_CHANNEL = 'WITH_ACCOUNT_AND_CHANNEL'
+}
+
+type AvailableForListOptions = {
+  followerActorId: number
+  type?: VideoPlaylistType
+  accountId?: number
+  videoChannelId?: number
+  privateAndUnlisted?: boolean
+}
+
+@Scopes(() => ({
+  [ ScopeNames.WITH_THUMBNAIL ]: {
+    include: [
+      {
+        model: ThumbnailModel,
+        required: false
+      }
+    ]
+  },
+  [ ScopeNames.WITH_VIDEOS_LENGTH ]: {
+    attributes: {
+      include: [
+        [
+          literal('(SELECT COUNT("id") FROM "videoPlaylistElement" WHERE "videoPlaylistId" = "VideoPlaylistModel"."id")'),
+          'videosLength'
+        ]
+      ]
+    }
+  } as FindOptions,
+  [ ScopeNames.WITH_ACCOUNT ]: {
+    include: [
+      {
+        model: AccountModel,
+        required: true
+      }
+    ]
+  },
+  [ ScopeNames.WITH_ACCOUNT_AND_CHANNEL_SUMMARY ]: {
+    include: [
+      {
+        model: AccountModel.scope(AccountScopeNames.SUMMARY),
+        required: true
+      },
+      {
+        model: VideoChannelModel.scope(VideoChannelScopeNames.SUMMARY),
+        required: false
+      }
+    ]
+  },
+  [ ScopeNames.WITH_ACCOUNT_AND_CHANNEL ]: {
+    include: [
+      {
+        model: AccountModel,
+        required: true
+      },
+      {
+        model: VideoChannelModel,
+        required: false
+      }
+    ]
+  },
+  [ ScopeNames.AVAILABLE_FOR_LIST ]: (options: AvailableForListOptions) => {
+    // Only list local playlists OR playlists that are on an instance followed by actorId
+    const inQueryInstanceFollow = buildServerIdsFollowedBy(options.followerActorId)
+    const actorWhere = {
+      [ Op.or ]: [
+        {
+          serverId: null
+        },
+        {
+          serverId: {
+            [ Op.in ]: literal(inQueryInstanceFollow)
+          }
+        }
+      ]
+    }
+
+    const whereAnd: WhereOptions[] = []
+
+    if (options.privateAndUnlisted !== true) {
+      whereAnd.push({
+        privacy: VideoPlaylistPrivacy.PUBLIC
+      })
+    }
+
+    if (options.accountId) {
+      whereAnd.push({
+        ownerAccountId: options.accountId
+      })
+    }
+
+    if (options.videoChannelId) {
+      whereAnd.push({
+        videoChannelId: options.videoChannelId
+      })
+    }
+
+    if (options.type) {
+      whereAnd.push({
+        type: options.type
+      })
+    }
+
+    const where = {
+      [Op.and]: whereAnd
+    }
+
+    const accountScope = {
+      method: [ AccountScopeNames.SUMMARY, actorWhere ]
+    }
+
+    return {
+      where,
+      include: [
+        {
+          model: AccountModel.scope(accountScope),
+          required: true
+        },
+        {
+          model: VideoChannelModel.scope(VideoChannelScopeNames.SUMMARY),
+          required: false
+        }
+      ]
+    } as FindOptions
+  }
+}))
+
+@Table({
+  tableName: 'videoPlaylist',
+  indexes: [
+    {
+      fields: [ 'ownerAccountId' ]
+    },
+    {
+      fields: [ 'videoChannelId' ]
+    },
+    {
+      fields: [ 'url' ],
+      unique: true
+    }
+  ]
+})
+export class VideoPlaylistModel extends Model<VideoPlaylistModel> {
+  @CreatedAt
+  createdAt: Date
+
+  @UpdatedAt
+  updatedAt: Date
+
+  @AllowNull(false)
+  @Is('VideoPlaylistName', value => throwIfNotValid(value, isVideoPlaylistNameValid, 'name'))
+  @Column
+  name: string
+
+  @AllowNull(true)
+  @Is('VideoPlaylistDescription', value => throwIfNotValid(value, isVideoPlaylistDescriptionValid, 'description', true))
+  @Column
+  description: string
+
+  @AllowNull(false)
+  @Is('VideoPlaylistPrivacy', value => throwIfNotValid(value, isVideoPlaylistPrivacyValid, 'privacy'))
+  @Column
+  privacy: VideoPlaylistPrivacy
+
+  @AllowNull(false)
+  @Is('VideoPlaylistUrl', value => throwIfNotValid(value, isActivityPubUrlValid, 'url'))
+  @Column(DataType.STRING(CONSTRAINTS_FIELDS.VIDEO_PLAYLISTS.URL.max))
+  url: string
+
+  @AllowNull(false)
+  @Default(DataType.UUIDV4)
+  @IsUUID(4)
+  @Column(DataType.UUID)
+  uuid: string
+
+  @AllowNull(false)
+  @Default(VideoPlaylistType.REGULAR)
+  @Column
+  type: VideoPlaylistType
+
+  @ForeignKey(() => AccountModel)
+  @Column
+  ownerAccountId: number
+
+  @BelongsTo(() => AccountModel, {
+    foreignKey: {
+      allowNull: false
+    },
+    onDelete: 'CASCADE'
+  })
+  OwnerAccount: AccountModel
+
+  @ForeignKey(() => VideoChannelModel)
+  @Column
+  videoChannelId: number
+
+  @BelongsTo(() => VideoChannelModel, {
+    foreignKey: {
+      allowNull: true
+    },
+    onDelete: 'CASCADE'
+  })
+  VideoChannel: VideoChannelModel
+
+  @HasMany(() => VideoPlaylistElementModel, {
+    foreignKey: {
+      name: 'videoPlaylistId',
+      allowNull: false
+    },
+    onDelete: 'CASCADE'
+  })
+  VideoPlaylistElements: VideoPlaylistElementModel[]
+
+  @HasOne(() => ThumbnailModel, {
+
+    foreignKey: {
+      name: 'videoPlaylistId',
+      allowNull: true
+    },
+    onDelete: 'CASCADE',
+    hooks: true
+  })
+  Thumbnail: ThumbnailModel
+
+  static listForApi (options: {
+    followerActorId: number
+    start: number,
+    count: number,
+    sort: string,
+    type?: VideoPlaylistType,
+    accountId?: number,
+    videoChannelId?: number,
+    privateAndUnlisted?: boolean
+  }) {
+    const query = {
+      offset: options.start,
+      limit: options.count,
+      order: getSort(options.sort)
+    }
+
+    const scopes: (string | ScopeOptions)[] = [
+      {
+        method: [
+          ScopeNames.AVAILABLE_FOR_LIST,
+          {
+            type: options.type,
+            followerActorId: options.followerActorId,
+            accountId: options.accountId,
+            videoChannelId: options.videoChannelId,
+            privateAndUnlisted: options.privateAndUnlisted
+          } as AvailableForListOptions
+        ]
+      },
+      ScopeNames.WITH_VIDEOS_LENGTH,
+      ScopeNames.WITH_THUMBNAIL
+    ]
+
+    return VideoPlaylistModel
+      .scope(scopes)
+      .findAndCountAll(query)
+      .then(({ rows, count }) => {
+        return { total: count, data: rows }
+      })
+  }
+
+  static listPublicUrlsOfForAP (accountId: number, start: number, count: number) {
+    const query = {
+      attributes: [ 'url' ],
+      offset: start,
+      limit: count,
+      where: {
+        ownerAccountId: accountId,
+        privacy: VideoPlaylistPrivacy.PUBLIC
+      }
+    }
+
+    return VideoPlaylistModel.findAndCountAll(query)
+                             .then(({ rows, count }) => {
+                               return { total: count, data: rows.map(p => p.url) }
+                             })
+  }
+
+  static listPlaylistIdsOf (accountId: number, videoIds: number[]) {
+    const query = {
+      attributes: [ 'id' ],
+      where: {
+        ownerAccountId: accountId
+      },
+      include: [
+        {
+          attributes: [ 'videoId', 'startTimestamp', 'stopTimestamp' ],
+          model: VideoPlaylistElementModel.unscoped(),
+          where: {
+            videoId: {
+              [Op.in]: videoIds // FIXME: sequelize ANY seems broken
+            }
+          },
+          required: true
+        }
+      ]
+    }
+
+    return VideoPlaylistModel.findAll(query)
+  }
+
+  static doesPlaylistExist (url: string) {
+    const query = {
+      attributes: [],
+      where: {
+        url
+      }
+    }
+
+    return VideoPlaylistModel
+      .findOne(query)
+      .then(e => !!e)
+  }
+
+  static loadWithAccountAndChannelSummary (id: number | string, transaction: Transaction) {
+    const where = buildWhereIdOrUUID(id)
+
+    const query = {
+      where,
+      transaction
+    }
+
+    return VideoPlaylistModel
+      .scope([ ScopeNames.WITH_ACCOUNT_AND_CHANNEL_SUMMARY, ScopeNames.WITH_VIDEOS_LENGTH, ScopeNames.WITH_THUMBNAIL ])
+      .findOne(query)
+  }
+
+  static loadWithAccountAndChannel (id: number | string, transaction: Transaction) {
+    const where = buildWhereIdOrUUID(id)
+
+    const query = {
+      where,
+      transaction
+    }
+
+    return VideoPlaylistModel
+      .scope([ ScopeNames.WITH_ACCOUNT_AND_CHANNEL, ScopeNames.WITH_VIDEOS_LENGTH, ScopeNames.WITH_THUMBNAIL ])
+      .findOne(query)
+  }
+
+  static loadByUrlAndPopulateAccount (url: string) {
+    const query = {
+      where: {
+        url
+      }
+    }
+
+    return VideoPlaylistModel.scope([ ScopeNames.WITH_ACCOUNT, ScopeNames.WITH_THUMBNAIL ]).findOne(query)
+  }
+
+  static getPrivacyLabel (privacy: VideoPlaylistPrivacy) {
+    return VIDEO_PLAYLIST_PRIVACIES[privacy] || 'Unknown'
+  }
+
+  static getTypeLabel (type: VideoPlaylistType) {
+    return VIDEO_PLAYLIST_TYPES[type] || 'Unknown'
+  }
+
+  static resetPlaylistsOfChannel (videoChannelId: number, transaction: Transaction) {
+    const query = {
+      where: {
+        videoChannelId
+      },
+      transaction
+    }
+
+    return VideoPlaylistModel.update({ privacy: VideoPlaylistPrivacy.PRIVATE, videoChannelId: null }, query)
+  }
+
+  async setAndSaveThumbnail (thumbnail: ThumbnailModel, t: Transaction) {
+    thumbnail.videoPlaylistId = this.id
+
+    this.Thumbnail = await thumbnail.save({ transaction: t })
+  }
+
+  hasThumbnail () {
+    return !!this.Thumbnail
+  }
+
+  generateThumbnailName () {
+    const extension = '.jpg'
+
+    return 'playlist-' + this.uuid + extension
+  }
+
+  getThumbnailUrl () {
+    if (!this.hasThumbnail()) return null
+
+    return WEBSERVER.URL + STATIC_PATHS.THUMBNAILS + this.Thumbnail.filename
+  }
+
+  getThumbnailStaticPath () {
+    if (!this.hasThumbnail()) return null
+
+    return join(STATIC_PATHS.THUMBNAILS, this.Thumbnail.filename)
+  }
+
+  setAsRefreshed () {
+    this.changed('updatedAt', true)
+
+    return this.save()
+  }
+
+  isOwned () {
+    return this.OwnerAccount.isOwned()
+  }
+
+  isOutdated () {
+    if (this.isOwned()) return false
+
+    return isOutdated(this, ACTIVITY_PUB.VIDEO_PLAYLIST_REFRESH_INTERVAL)
+  }
+
+  toFormattedJSON (): VideoPlaylist {
+    return {
+      id: this.id,
+      uuid: this.uuid,
+      isLocal: this.isOwned(),
+
+      displayName: this.name,
+      description: this.description,
+      privacy: {
+        id: this.privacy,
+        label: VideoPlaylistModel.getPrivacyLabel(this.privacy)
+      },
+
+      thumbnailPath: this.getThumbnailStaticPath(),
+
+      type: {
+        id: this.type,
+        label: VideoPlaylistModel.getTypeLabel(this.type)
+      },
+
+      videosLength: this.get('videosLength') as number,
+
+      createdAt: this.createdAt,
+      updatedAt: this.updatedAt,
+
+      ownerAccount: this.OwnerAccount.toFormattedSummaryJSON(),
+      videoChannel: this.VideoChannel ? this.VideoChannel.toFormattedSummaryJSON() : null
+    }
+  }
+
+  toActivityPubObject (page: number, t: Transaction): Promise<PlaylistObject> {
+    const handler = (start: number, count: number) => {
+      return VideoPlaylistElementModel.listUrlsOfForAP(this.id, start, count, t)
+    }
+
+    let icon: ActivityIconObject
+    if (this.hasThumbnail()) {
+      icon = {
+        type: 'Image' as 'Image',
+        url: this.getThumbnailUrl(),
+        mediaType: 'image/jpeg' as 'image/jpeg',
+        width: THUMBNAILS_SIZE.width,
+        height: THUMBNAILS_SIZE.height
+      }
+    }
+
+    return activityPubCollectionPagination(this.url, handler, page)
+      .then(o => {
+        return Object.assign(o, {
+          type: 'Playlist' as 'Playlist',
+          name: this.name,
+          content: this.description,
+          uuid: this.uuid,
+          published: this.createdAt.toISOString(),
+          updated: this.updatedAt.toISOString(),
+          attributedTo: this.VideoChannel ? [ this.VideoChannel.Actor.url ] : [],
+          icon
+        })
+      })
+  }
+}
diff --git a/server/models/video/video-share.ts b/server/models/video/video-share.ts
index c87f71277..fda2d7cea 100644
--- a/server/models/video/video-share.ts
+++ b/server/models/video/video-share.ts
@@ -2,7 +2,7 @@ import * as Sequelize from 'sequelize'
 import * as Bluebird from 'bluebird'
 import { AllowNull, BelongsTo, Column, CreatedAt, DataType, ForeignKey, Is, Model, Scopes, Table, UpdatedAt } from 'sequelize-typescript'
 import { isActivityPubUrlValid } from '../../helpers/custom-validators/activitypub/misc'
-import { CONSTRAINTS_FIELDS } from '../../initializers'
+import { CONSTRAINTS_FIELDS } from '../../initializers/constants'
 import { AccountModel } from '../account/account'
 import { ActorModel } from '../activitypub/actor'
 import { throwIfNotValid } from '../utils'
@@ -14,15 +14,15 @@ enum ScopeNames {
   WITH_ACTOR = 'WITH_ACTOR'
 }
 
-@Scopes({
+@Scopes(() => ({
   [ScopeNames.FULL]: {
     include: [
       {
-        model: () => ActorModel,
+        model: ActorModel,
         required: true
       },
       {
-        model: () => VideoModel,
+        model: VideoModel,
         required: true
       }
     ]
@@ -30,12 +30,12 @@ enum ScopeNames {
   [ScopeNames.WITH_ACTOR]: {
     include: [
       {
-        model: () => ActorModel,
+        model: ActorModel,
         required: true
       }
     ]
   }
-})
+}))
 @Table({
   tableName: 'videoShare',
   indexes: [
@@ -125,7 +125,7 @@ export class VideoShareModel extends Model<VideoShareModel> {
       .then(res => res.map(r => r.Actor))
   }
 
-  static loadActorsByVideoOwner (actorOwnerId: number, t: Sequelize.Transaction): Bluebird<ActorModel[]> {
+  static loadActorsWhoSharedVideosOf (actorOwnerId: number, t: Sequelize.Transaction): Bluebird<ActorModel[]> {
     const query = {
       attributes: [],
       include: [
@@ -200,4 +200,17 @@ export class VideoShareModel extends Model<VideoShareModel> {
 
     return VideoShareModel.findAndCountAll(query)
   }
+
+  static cleanOldSharesOf (videoId: number, beforeUpdatedAt: Date) {
+    const query = {
+      where: {
+        updatedAt: {
+          [Sequelize.Op.lt]: beforeUpdatedAt
+        },
+        videoId
+      }
+    }
+
+    return VideoShareModel.destroy(query)
+  }
 }
diff --git a/server/models/video/video-streaming-playlist.ts b/server/models/video/video-streaming-playlist.ts
new file mode 100644
index 000000000..31dc82c54
--- /dev/null
+++ b/server/models/video/video-streaming-playlist.ts
@@ -0,0 +1,172 @@
+import { AllowNull, BelongsTo, Column, CreatedAt, ForeignKey, HasMany, Is, Model, Table, UpdatedAt, DataType } from 'sequelize-typescript'
+import { isVideoFileInfoHashValid } from '../../helpers/custom-validators/videos'
+import { throwIfNotValid } from '../utils'
+import { VideoModel } from './video'
+import { VideoRedundancyModel } from '../redundancy/video-redundancy'
+import { VideoStreamingPlaylistType } from '../../../shared/models/videos/video-streaming-playlist.type'
+import { isActivityPubUrlValid } from '../../helpers/custom-validators/activitypub/misc'
+import { CONSTRAINTS_FIELDS, STATIC_PATHS, P2P_MEDIA_LOADER_PEER_VERSION } from '../../initializers/constants'
+import { VideoFileModel } from './video-file'
+import { join } from 'path'
+import { sha1 } from '../../helpers/core-utils'
+import { isArrayOf } from '../../helpers/custom-validators/misc'
+import { QueryTypes, Op } from 'sequelize'
+
+@Table({
+  tableName: 'videoStreamingPlaylist',
+  indexes: [
+    {
+      fields: [ 'videoId' ]
+    },
+    {
+      fields: [ 'videoId', 'type' ],
+      unique: true
+    },
+    {
+      fields: [ 'p2pMediaLoaderInfohashes' ],
+      using: 'gin'
+    }
+  ]
+})
+export class VideoStreamingPlaylistModel extends Model<VideoStreamingPlaylistModel> {
+  @CreatedAt
+  createdAt: Date
+
+  @UpdatedAt
+  updatedAt: Date
+
+  @AllowNull(false)
+  @Column
+  type: VideoStreamingPlaylistType
+
+  @AllowNull(false)
+  @Is('PlaylistUrl', value => throwIfNotValid(value, isActivityPubUrlValid, 'playlist url'))
+  @Column(DataType.STRING(CONSTRAINTS_FIELDS.VIDEOS.URL.max))
+  playlistUrl: string
+
+  @AllowNull(false)
+  @Is('VideoStreamingPlaylistInfoHashes', value => throwIfNotValid(value, v => isArrayOf(v, isVideoFileInfoHashValid), 'info hashes'))
+  @Column(DataType.ARRAY(DataType.STRING))
+  p2pMediaLoaderInfohashes: string[]
+
+  @AllowNull(false)
+  @Column
+  p2pMediaLoaderPeerVersion: number
+
+  @AllowNull(false)
+  @Is('VideoStreamingSegmentsSha256Url', value => throwIfNotValid(value, isActivityPubUrlValid, 'segments sha256 url'))
+  @Column
+  segmentsSha256Url: string
+
+  @ForeignKey(() => VideoModel)
+  @Column
+  videoId: number
+
+  @BelongsTo(() => VideoModel, {
+    foreignKey: {
+      allowNull: false
+    },
+    onDelete: 'CASCADE'
+  })
+  Video: VideoModel
+
+  @HasMany(() => VideoRedundancyModel, {
+    foreignKey: {
+      allowNull: false
+    },
+    onDelete: 'CASCADE',
+    hooks: true
+  })
+  RedundancyVideos: VideoRedundancyModel[]
+
+  static doesInfohashExist (infoHash: string) {
+    const query = 'SELECT 1 FROM "videoStreamingPlaylist" WHERE $infoHash = ANY("p2pMediaLoaderInfohashes") LIMIT 1'
+    const options = {
+      type: QueryTypes.SELECT as QueryTypes.SELECT,
+      bind: { infoHash },
+      raw: true
+    }
+
+    return VideoModel.sequelize.query<object>(query, options)
+              .then(results => results.length === 1)
+  }
+
+  static buildP2PMediaLoaderInfoHashes (playlistUrl: string, videoFiles: VideoFileModel[]) {
+    const hashes: string[] = []
+
+    // https://github.com/Novage/p2p-media-loader/blob/master/p2p-media-loader-core/lib/p2p-media-manager.ts#L115
+    for (let i = 0; i < videoFiles.length; i++) {
+      hashes.push(sha1(`${P2P_MEDIA_LOADER_PEER_VERSION}${playlistUrl}+V${i}`))
+    }
+
+    return hashes
+  }
+
+  static listByIncorrectPeerVersion () {
+    const query = {
+      where: {
+        p2pMediaLoaderPeerVersion: {
+          [Op.ne]: P2P_MEDIA_LOADER_PEER_VERSION
+        }
+      }
+    }
+
+    return VideoStreamingPlaylistModel.findAll(query)
+  }
+
+  static loadWithVideo (id: number) {
+    const options = {
+      include: [
+        {
+          model: VideoModel.unscoped(),
+          required: true
+        }
+      ]
+    }
+
+    return VideoStreamingPlaylistModel.findByPk(id, options)
+  }
+
+  static getHlsPlaylistFilename (resolution: number) {
+    return resolution + '.m3u8'
+  }
+
+  static getMasterHlsPlaylistFilename () {
+    return 'master.m3u8'
+  }
+
+  static getHlsSha256SegmentsFilename () {
+    return 'segments-sha256.json'
+  }
+
+  static getHlsVideoName (uuid: string, resolution: number) {
+    return `${uuid}-${resolution}-fragmented.mp4`
+  }
+
+  static getHlsMasterPlaylistStaticPath (videoUUID: string) {
+    return join(STATIC_PATHS.STREAMING_PLAYLISTS.HLS, videoUUID, VideoStreamingPlaylistModel.getMasterHlsPlaylistFilename())
+  }
+
+  static getHlsPlaylistStaticPath (videoUUID: string, resolution: number) {
+    return join(STATIC_PATHS.STREAMING_PLAYLISTS.HLS, videoUUID, VideoStreamingPlaylistModel.getHlsPlaylistFilename(resolution))
+  }
+
+  static getHlsSha256SegmentsStaticPath (videoUUID: string) {
+    return join(STATIC_PATHS.STREAMING_PLAYLISTS.HLS, videoUUID, VideoStreamingPlaylistModel.getHlsSha256SegmentsFilename())
+  }
+
+  getStringType () {
+    if (this.type === VideoStreamingPlaylistType.HLS) return 'hls'
+
+    return 'unknown'
+  }
+
+  getVideoRedundancyUrl (baseUrlHttp: string) {
+    return baseUrlHttp + STATIC_PATHS.REDUNDANCY + this.getStringType() + '/' + this.Video.uuid
+  }
+
+  hasSameUniqueKeysThan (other: VideoStreamingPlaylistModel) {
+    return this.type === other.type &&
+      this.videoId === other.videoId
+  }
+}
diff --git a/server/models/video/video-views.ts b/server/models/video/video-views.ts
index fde5f7056..40db5effd 100644
--- a/server/models/video/video-views.ts
+++ b/server/models/video/video-views.ts
@@ -4,6 +4,7 @@ import * as Sequelize from 'sequelize'
 
 @Table({
   tableName: 'videoView',
+  updatedAt: false,
   indexes: [
     {
       fields: [ 'videoId' ]
@@ -41,4 +42,18 @@ export class VideoViewModel extends Model<VideoViewModel> {
   })
   Video: VideoModel
 
+  static removeOldRemoteViewsHistory (beforeDate: string) {
+    const query = {
+      where: {
+        startDate: {
+          [Sequelize.Op.lt]: beforeDate
+        },
+        videoId: {
+          [Sequelize.Op.in]: Sequelize.literal('(SELECT "id" FROM "video" WHERE "remote" IS TRUE)')
+        }
+      }
+    }
+
+    return VideoViewModel.destroy(query)
+  }
 }
diff --git a/server/models/video/video.ts b/server/models/video/video.ts
index 80a6c7832..c0a7892a4 100644
--- a/server/models/video/video.ts
+++ b/server/models/video/video.ts
@@ -3,7 +3,18 @@ import { maxBy } from 'lodash'
 import * as magnetUtil from 'magnet-uri'
 import * as parseTorrent from 'parse-torrent'
 import { join } from 'path'
-import * as Sequelize from 'sequelize'
+import {
+  CountOptions,
+  FindOptions,
+  IncludeOptions,
+  ModelIndexesOptions,
+  Op,
+  QueryTypes,
+  ScopeOptions,
+  Sequelize,
+  Transaction,
+  WhereOptions
+} from 'sequelize'
 import {
   AllowNull,
   BeforeDestroy,
@@ -16,8 +27,6 @@ import {
   ForeignKey,
   HasMany,
   HasOne,
-  IFindOptions,
-  IIncludeOptions,
   Is,
   IsInt,
   IsUUID,
@@ -45,35 +54,43 @@ import {
   isVideoStateValid,
   isVideoSupportValid
 } from '../../helpers/custom-validators/videos'
-import { generateImageFromVideoFile, getVideoFileResolution } from '../../helpers/ffmpeg-utils'
+import { getVideoFileResolution } from '../../helpers/ffmpeg-utils'
 import { logger } from '../../helpers/logger'
 import { getServerActor } from '../../helpers/utils'
 import {
   ACTIVITY_PUB,
   API_VERSION,
-  CONFIG,
   CONSTRAINTS_FIELDS,
-  PREVIEWS_SIZE,
+  HLS_REDUNDANCY_DIRECTORY,
+  HLS_STREAMING_PLAYLIST_DIRECTORY,
   REMOTE_SCHEME,
   STATIC_DOWNLOAD_PATHS,
   STATIC_PATHS,
-  THUMBNAILS_SIZE,
   VIDEO_CATEGORIES,
   VIDEO_LANGUAGES,
   VIDEO_LICENCES,
   VIDEO_PRIVACIES,
-  VIDEO_STATES
-} from '../../initializers'
+  VIDEO_STATES,
+  WEBSERVER
+} from '../../initializers/constants'
 import { sendDeleteVideo } from '../../lib/activitypub/send'
 import { AccountModel } from '../account/account'
 import { AccountVideoRateModel } from '../account/account-video-rate'
 import { ActorModel } from '../activitypub/actor'
 import { AvatarModel } from '../avatar/avatar'
 import { ServerModel } from '../server/server'
-import { buildBlockedAccountSQL, buildTrigramSearchIndex, createSimilarityAttribute, getVideoSort, throwIfNotValid } from '../utils'
+import {
+  buildBlockedAccountSQL,
+  buildTrigramSearchIndex,
+  buildWhereIdOrUUID,
+  createSimilarityAttribute,
+  getVideoSort,
+  isOutdated,
+  throwIfNotValid
+} from '../utils'
 import { TagModel } from './tag'
 import { VideoAbuseModel } from './video-abuse'
-import { VideoChannelModel } from './video-channel'
+import { ScopeNames as VideoChannelScopeNames, VideoChannelModel } from './video-channel'
 import { VideoCommentModel } from './video-comment'
 import { VideoFileModel } from './video-file'
 import { VideoShareModel } from './video-share'
@@ -91,13 +108,17 @@ import {
   videoModelToFormattedDetailsJSON,
   videoModelToFormattedJSON
 } from './video-format-utils'
-import * as validator from 'validator'
 import { UserVideoHistoryModel } from '../account/user-video-history'
 import { UserModel } from '../account/user'
 import { VideoImportModel } from './video-import'
+import { VideoStreamingPlaylistModel } from './video-streaming-playlist'
+import { VideoPlaylistElementModel } from './video-playlist-element'
+import { CONFIG } from '../../initializers/config'
+import { ThumbnailModel } from './thumbnail'
+import { ThumbnailType } from '../../../shared/models/videos/thumbnail.type'
 
 // FIXME: Define indexes here because there is an issue with TS and Sequelize.literal when called directly in the annotation
-const indexes: Sequelize.DefineIndexesOptions[] = [
+const indexes: (ModelIndexesOptions & { where?: WhereOptions })[] = [
   buildTrigramSearchIndex('video_name_trigram', 'name'),
 
   { fields: [ 'createdAt' ] },
@@ -106,10 +127,18 @@ const indexes: Sequelize.DefineIndexesOptions[] = [
   { fields: [ 'views' ] },
   { fields: [ 'channelId' ] },
   {
+    fields: [ 'originallyPublishedAt' ],
+    where: {
+      originallyPublishedAt: {
+        [Op.ne]: null
+      }
+    }
+  },
+  {
     fields: [ 'category' ], // We don't care videos with an unknown category
     where: {
       category: {
-        [Sequelize.Op.ne]: null
+        [Op.ne]: null
       }
     }
   },
@@ -117,7 +146,7 @@ const indexes: Sequelize.DefineIndexesOptions[] = [
     fields: [ 'licence' ], // We don't care videos with an unknown licence
     where: {
       licence: {
-        [Sequelize.Op.ne]: null
+        [Op.ne]: null
       }
     }
   },
@@ -125,7 +154,7 @@ const indexes: Sequelize.DefineIndexesOptions[] = [
     fields: [ 'language' ], // We don't care videos with an unknown language
     where: {
       language: {
-        [Sequelize.Op.ne]: null
+        [Op.ne]: null
       }
     }
   },
@@ -159,11 +188,17 @@ export enum ScopeNames {
   WITH_FILES = 'WITH_FILES',
   WITH_SCHEDULED_UPDATE = 'WITH_SCHEDULED_UPDATE',
   WITH_BLACKLISTED = 'WITH_BLACKLISTED',
-  WITH_USER_HISTORY = 'WITH_USER_HISTORY'
+  WITH_USER_HISTORY = 'WITH_USER_HISTORY',
+  WITH_STREAMING_PLAYLISTS = 'WITH_STREAMING_PLAYLISTS',
+  WITH_USER_ID = 'WITH_USER_ID',
+  WITH_THUMBNAILS = 'WITH_THUMBNAILS'
 }
 
 type ForAPIOptions = {
   ids: number[]
+
+  videoPlaylistId?: number
+
   withFiles?: boolean
 }
 
@@ -171,6 +206,9 @@ type AvailableForListIDsOptions = {
   serverAccountId: number
   followerActorId: number
   includeLocalVideos: boolean
+
+  withoutId?: boolean
+
   filter?: VideoFilter
   categoryOneOf?: number[]
   nsfw?: boolean
@@ -178,72 +216,38 @@ type AvailableForListIDsOptions = {
   languageOneOf?: string[]
   tagsOneOf?: string[]
   tagsAllOf?: string[]
+
   withFiles?: boolean
+
   accountId?: number
   videoChannelId?: number
+
+  videoPlaylistId?: number
+
   trendingDays?: number
   user?: UserModel,
   historyOfUser?: UserModel
 }
 
-@Scopes({
+@Scopes(() => ({
   [ ScopeNames.FOR_API ]: (options: ForAPIOptions) => {
-    const accountInclude = {
-      attributes: [ 'id', 'name' ],
-      model: AccountModel.unscoped(),
-      required: true,
-      include: [
-        {
-          attributes: [ 'id', 'uuid', 'preferredUsername', 'url', 'serverId', 'avatarId' ],
-          model: ActorModel.unscoped(),
-          required: true,
-          include: [
-            {
-              attributes: [ 'host' ],
-              model: ServerModel.unscoped(),
-              required: false
-            },
-            {
-              model: AvatarModel.unscoped(),
-              required: false
-            }
-          ]
+    const query: FindOptions = {
+      where: {
+        id: {
+          [ Op.in ]: options.ids // FIXME: sequelize ANY seems broken
         }
-      ]
-    }
-
-    const videoChannelInclude = {
-      attributes: [ 'name', 'description', 'id' ],
-      model: VideoChannelModel.unscoped(),
-      required: true,
+      },
       include: [
         {
-          attributes: [ 'uuid', 'preferredUsername', 'url', 'serverId', 'avatarId' ],
-          model: ActorModel.unscoped(),
-          required: true,
-          include: [
-            {
-              attributes: [ 'host' ],
-              model: ServerModel.unscoped(),
-              required: false
-            },
-            {
-              model: AvatarModel.unscoped(),
-              required: false
-            }
-          ]
+          model: VideoChannelModel.scope({ method: [ VideoChannelScopeNames.SUMMARY, true ] }),
+          required: true
         },
-        accountInclude
-      ]
-    }
-
-    const query: IFindOptions<VideoModel> = {
-      where: {
-        id: {
-          [ Sequelize.Op.any ]: options.ids
+        {
+          attributes: [ 'type', 'filename' ],
+          model: ThumbnailModel,
+          required: false
         }
-      },
-      include: [ videoChannelInclude ]
+      ]
     }
 
     if (options.withFiles === true) {
@@ -253,24 +257,36 @@ type AvailableForListIDsOptions = {
       })
     }
 
+    if (options.videoPlaylistId) {
+      query.include.push({
+        model: VideoPlaylistElementModel.unscoped(),
+        required: true,
+        where: {
+          videoPlaylistId: options.videoPlaylistId
+        }
+      })
+    }
+
     return query
   },
   [ ScopeNames.AVAILABLE_FOR_LIST_IDS ]: (options: AvailableForListIDsOptions) => {
-    const query: IFindOptions<VideoModel> = {
+    const attributes = options.withoutId === true ? [] : [ 'id' ]
+
+    const query: FindOptions = {
       raw: true,
-      attributes: [ 'id' ],
+      attributes,
       where: {
         id: {
-          [ Sequelize.Op.and ]: [
+          [ Op.and ]: [
             {
-              [ Sequelize.Op.notIn ]: Sequelize.literal(
+              [ Op.notIn ]: Sequelize.literal(
                 '(SELECT "videoBlacklist"."videoId" FROM "videoBlacklist")'
               )
             }
           ]
         },
         channelId: {
-          [ Sequelize.Op.notIn ]: Sequelize.literal(
+          [ Op.notIn ]: Sequelize.literal(
             '(' +
               'SELECT id FROM "videoChannel" WHERE "accountId" IN (' +
                 buildBlockedAccountSQL(options.serverAccountId, options.user ? options.user.Account.id : undefined) +
@@ -288,12 +304,12 @@ type AvailableForListIDsOptions = {
         // Always list public videos
         privacy: VideoPrivacy.PUBLIC,
         // Always list published videos, or videos that are being transcoded but on which we don't want to wait for transcoding
-        [ Sequelize.Op.or ]: [
+        [ Op.or ]: [
           {
             state: VideoState.PUBLISHED
           },
           {
-            [ Sequelize.Op.and ]: {
+            [ Op.and ]: {
               state: VideoState.TO_TRANSCODE,
               waitTranscoding: false
             }
@@ -304,8 +320,21 @@ type AvailableForListIDsOptions = {
       Object.assign(query.where, privacyWhere)
     }
 
+    if (options.videoPlaylistId) {
+      query.include.push({
+        attributes: [],
+        model: VideoPlaylistElementModel.unscoped(),
+        required: true,
+        where: {
+          videoPlaylistId: options.videoPlaylistId
+        }
+      })
+
+      query.subQuery = false
+    }
+
     if (options.filter || options.accountId || options.videoChannelId) {
-      const videoChannelInclude: IIncludeOptions = {
+      const videoChannelInclude: IncludeOptions = {
         attributes: [],
         model: VideoChannelModel.unscoped(),
         required: true
@@ -318,7 +347,7 @@ type AvailableForListIDsOptions = {
       }
 
       if (options.filter || options.accountId) {
-        const accountInclude: IIncludeOptions = {
+        const accountInclude: IncludeOptions = {
           attributes: [],
           model: AccountModel.unscoped(),
           required: true
@@ -358,8 +387,8 @@ type AvailableForListIDsOptions = {
 
       // Force actorId to be a number to avoid SQL injections
       const actorIdNumber = parseInt(options.followerActorId.toString(), 10)
-      query.where[ 'id' ][ Sequelize.Op.and ].push({
-        [ Sequelize.Op.in ]: Sequelize.literal(
+      query.where[ 'id' ][ Op.and ].push({
+        [ Op.in ]: Sequelize.literal(
           '(' +
           'SELECT "videoShare"."videoId" AS "id" FROM "videoShare" ' +
           'INNER JOIN "actorFollow" ON "actorFollow"."targetActorId" = "videoShare"."actorId" ' +
@@ -378,8 +407,8 @@ type AvailableForListIDsOptions = {
     }
 
     if (options.withFiles === true) {
-      query.where[ 'id' ][ Sequelize.Op.and ].push({
-        [ Sequelize.Op.in ]: Sequelize.literal(
+      query.where[ 'id' ][ Op.and ].push({
+        [ Op.in ]: Sequelize.literal(
           '(SELECT "videoId" FROM "videoFile")'
         )
       })
@@ -393,8 +422,8 @@ type AvailableForListIDsOptions = {
       }
 
       if (options.tagsOneOf) {
-        query.where[ 'id' ][ Sequelize.Op.and ].push({
-          [ Sequelize.Op.in ]: Sequelize.literal(
+        query.where[ 'id' ][ Op.and ].push({
+          [ Op.in ]: Sequelize.literal(
             '(' +
             'SELECT "videoId" FROM "videoTag" ' +
             'INNER JOIN "tag" ON "tag"."id" = "videoTag"."tagId" ' +
@@ -405,8 +434,8 @@ type AvailableForListIDsOptions = {
       }
 
       if (options.tagsAllOf) {
-        query.where[ 'id' ][ Sequelize.Op.and ].push({
-          [ Sequelize.Op.in ]: Sequelize.literal(
+        query.where[ 'id' ][ Op.and ].push({
+          [ Op.in ]: Sequelize.literal(
             '(' +
             'SELECT "videoId" FROM "videoTag" ' +
             'INNER JOIN "tag" ON "tag"."id" = "videoTag"."tagId" ' +
@@ -424,19 +453,19 @@ type AvailableForListIDsOptions = {
 
     if (options.categoryOneOf) {
       query.where[ 'category' ] = {
-        [ Sequelize.Op.or ]: options.categoryOneOf
+        [ Op.or ]: options.categoryOneOf
       }
     }
 
     if (options.licenceOneOf) {
       query.where[ 'licence' ] = {
-        [ Sequelize.Op.or ]: options.licenceOneOf
+        [ Op.or ]: options.licenceOneOf
       }
     }
 
     if (options.languageOneOf) {
       query.where[ 'language' ] = {
-        [ Sequelize.Op.or ]: options.languageOneOf
+        [ Op.or ]: options.languageOneOf
       }
     }
 
@@ -463,36 +492,60 @@ type AvailableForListIDsOptions = {
 
     return query
   },
+  [ ScopeNames.WITH_THUMBNAILS ]: {
+    include: [
+      {
+        model: ThumbnailModel,
+        required: false
+      }
+    ]
+  },
+  [ ScopeNames.WITH_USER_ID ]: {
+    include: [
+      {
+        attributes: [ 'accountId' ],
+        model: VideoChannelModel.unscoped(),
+        required: true,
+        include: [
+          {
+            attributes: [ 'userId' ],
+            model: AccountModel.unscoped(),
+            required: true
+          }
+        ]
+      }
+    ]
+  },
   [ ScopeNames.WITH_ACCOUNT_DETAILS ]: {
     include: [
       {
-        model: () => VideoChannelModel.unscoped(),
+        model: VideoChannelModel.unscoped(),
         required: true,
         include: [
           {
             attributes: {
               exclude: [ 'privateKey', 'publicKey' ]
             },
-            model: () => ActorModel.unscoped(),
+            model: ActorModel.unscoped(),
             required: true,
             include: [
               {
                 attributes: [ 'host' ],
-                model: () => ServerModel.unscoped(),
+                model: ServerModel.unscoped(),
                 required: false
               },
               {
-                model: () => AvatarModel.unscoped(),
+                model: AvatarModel.unscoped(),
                 required: false
               }
             ]
           },
           {
-            model: () => AccountModel.unscoped(),
+            model: AccountModel.unscoped(),
             required: true,
             include: [
               {
-                model: () => ActorModel.unscoped(),
+                model: ActorModel.unscoped(),
                 attributes: {
                   exclude: [ 'privateKey', 'publicKey' ]
                 },
@@ -500,11 +553,11 @@ type AvailableForListIDsOptions = {
                 include: [
                   {
                     attributes: [ 'host' ],
-                    model: () => ServerModel.unscoped(),
+                    model: ServerModel.unscoped(),
                     required: false
                   },
                   {
-                    model: () => AvatarModel.unscoped(),
+                    model: AvatarModel.unscoped(),
                     required: false
                   }
                 ]
@@ -516,38 +569,69 @@ type AvailableForListIDsOptions = {
     ]
   },
   [ ScopeNames.WITH_TAGS ]: {
-    include: [ () => TagModel ]
+    include: [ TagModel ]
   },
   [ ScopeNames.WITH_BLACKLISTED ]: {
     include: [
       {
         attributes: [ 'id', 'reason' ],
-        model: () => VideoBlacklistModel,
+        model: VideoBlacklistModel,
         required: false
       }
     ]
   },
-  [ ScopeNames.WITH_FILES ]: {
-    include: [
-      {
-        model: () => VideoFileModel.unscoped(),
-        // FIXME: typings
-        [ 'separate' as any ]: true, // We may have multiple files, having multiple redundancies so let's separate this join
-        required: false,
-        include: [
-          {
-            attributes: [ 'fileUrl' ],
-            model: () => VideoRedundancyModel.unscoped(),
-            required: false
-          }
-        ]
-      }
-    ]
+  [ ScopeNames.WITH_FILES ]: (withRedundancies = false) => {
+    let subInclude: any[] = []
+
+    if (withRedundancies === true) {
+      subInclude = [
+        {
+          attributes: [ 'fileUrl' ],
+          model: VideoRedundancyModel.unscoped(),
+          required: false
+        }
+      ]
+    }
+
+    return {
+      include: [
+        {
+          model: VideoFileModel.unscoped(),
+          separate: true, // We may have multiple files, having multiple redundancies so let's separate this join
+          required: false,
+          include: subInclude
+        }
+      ]
+    }
+  },
+  [ ScopeNames.WITH_STREAMING_PLAYLISTS ]: (withRedundancies = false) => {
+    let subInclude: any[] = []
+
+    if (withRedundancies === true) {
+      subInclude = [
+        {
+          attributes: [ 'fileUrl' ],
+          model: VideoRedundancyModel.unscoped(),
+          required: false
+        }
+      ]
+    }
+
+    return {
+      include: [
+        {
+          model: VideoStreamingPlaylistModel.unscoped(),
+          separate: true, // We may have multiple streaming playlists, having multiple redundancies so let's separate this join
+          required: false,
+          include: subInclude
+        }
+      ]
+    }
   },
   [ ScopeNames.WITH_SCHEDULED_UPDATE ]: {
     include: [
       {
-        model: () => ScheduleVideoUpdateModel.unscoped(),
+        model: ScheduleVideoUpdateModel.unscoped(),
         required: false
       }
     ]
@@ -566,7 +650,7 @@ type AvailableForListIDsOptions = {
       ]
     }
   }
-})
+}))
 @Table({
   tableName: 'video',
   indexes
@@ -586,19 +670,19 @@ export class VideoModel extends Model<VideoModel> {
 
   @AllowNull(true)
   @Default(null)
-  @Is('VideoCategory', value => throwIfNotValid(value, isVideoCategoryValid, 'category'))
+  @Is('VideoCategory', value => throwIfNotValid(value, isVideoCategoryValid, 'category', true))
   @Column
   category: number
 
   @AllowNull(true)
   @Default(null)
-  @Is('VideoLicence', value => throwIfNotValid(value, isVideoLicenceValid, 'licence'))
+  @Is('VideoLicence', value => throwIfNotValid(value, isVideoLicenceValid, 'licence', true))
   @Column
   licence: number
 
   @AllowNull(true)
   @Default(null)
-  @Is('VideoLanguage', value => throwIfNotValid(value, isVideoLanguageValid, 'language'))
+  @Is('VideoLanguage', value => throwIfNotValid(value, isVideoLanguageValid, 'language', true))
   @Column(DataType.STRING(CONSTRAINTS_FIELDS.VIDEOS.LANGUAGE.max))
   language: string
 
@@ -614,13 +698,13 @@ export class VideoModel extends Model<VideoModel> {
 
   @AllowNull(true)
   @Default(null)
-  @Is('VideoDescription', value => throwIfNotValid(value, isVideoDescriptionValid, 'description'))
+  @Is('VideoDescription', value => throwIfNotValid(value, isVideoDescriptionValid, 'description', true))
   @Column(DataType.STRING(CONSTRAINTS_FIELDS.VIDEOS.DESCRIPTION.max))
   description: string
 
   @AllowNull(true)
   @Default(null)
-  @Is('VideoSupport', value => throwIfNotValid(value, isVideoSupportValid, 'support'))
+  @Is('VideoSupport', value => throwIfNotValid(value, isVideoSupportValid, 'support', true))
   @Column(DataType.STRING(CONSTRAINTS_FIELDS.VIDEOS.SUPPORT.max))
   support: string
 
@@ -665,6 +749,10 @@ export class VideoModel extends Model<VideoModel> {
 
   @AllowNull(false)
   @Column
+  downloadEnabled: boolean
+
+  @AllowNull(false)
+  @Column
   waitTranscoding: boolean
 
   @AllowNull(false)
@@ -680,10 +768,15 @@ export class VideoModel extends Model<VideoModel> {
   updatedAt: Date
 
   @AllowNull(false)
-  @Default(Sequelize.NOW)
+  @Default(DataType.NOW)
   @Column
   publishedAt: Date
 
+  @AllowNull(true)
+  @Default(null)
+  @Column
+  originallyPublishedAt: Date
+
   @ForeignKey(() => VideoChannelModel)
   @Column
   channelId: number
@@ -703,6 +796,25 @@ export class VideoModel extends Model<VideoModel> {
   })
   Tags: TagModel[]
 
+  @HasMany(() => ThumbnailModel, {
+    foreignKey: {
+      name: 'videoId',
+      allowNull: true
+    },
+    hooks: true,
+    onDelete: 'cascade'
+  })
+  Thumbnails: ThumbnailModel[]
+
+  @HasMany(() => VideoPlaylistElementModel, {
+    foreignKey: {
+      name: 'videoId',
+      allowNull: false
+    },
+    onDelete: 'cascade'
+  })
+  VideoPlaylistElements: VideoPlaylistElementModel[]
+
   @HasMany(() => VideoAbuseModel, {
     foreignKey: {
       name: 'videoId',
@@ -722,6 +834,16 @@ export class VideoModel extends Model<VideoModel> {
   })
   VideoFiles: VideoFileModel[]
 
+  @HasMany(() => VideoStreamingPlaylistModel, {
+    foreignKey: {
+      name: 'videoId',
+      allowNull: false
+    },
+    hooks: true,
+    onDelete: 'cascade'
+  })
+  VideoStreamingPlaylists: VideoStreamingPlaylistModel[]
+
   @HasMany(() => VideoShareModel, {
     foreignKey: {
       name: 'videoId',
@@ -833,20 +955,19 @@ export class VideoModel extends Model<VideoModel> {
 
     logger.info('Removing files of video %s.', instance.url)
 
-    tasks.push(instance.removeThumbnail())
-
     if (instance.isOwned()) {
       if (!Array.isArray(instance.VideoFiles)) {
         instance.VideoFiles = await instance.$get('VideoFiles') as VideoFileModel[]
       }
 
-      tasks.push(instance.removePreview())
-
       // Remove physical files and torrents
       instance.VideoFiles.forEach(file => {
         tasks.push(instance.removeFile(file))
         tasks.push(instance.removeTorrent(file))
       })
+
+      // Remove playlists file
+      tasks.push(instance.removeStreamingPlaylist())
     }
 
     // Do not wait video deletion because we could be in a transaction
@@ -858,10 +979,6 @@ export class VideoModel extends Model<VideoModel> {
     return undefined
   }
 
-  static list () {
-    return VideoModel.scope(ScopeNames.WITH_FILES).findAll()
-  }
-
   static listLocal () {
     const query = {
       where: {
@@ -869,7 +986,11 @@ export class VideoModel extends Model<VideoModel> {
       }
     }
 
-    return VideoModel.scope(ScopeNames.WITH_FILES).findAll(query)
+    return VideoModel.scope([
+      ScopeNames.WITH_FILES,
+      ScopeNames.WITH_STREAMING_PLAYLISTS,
+      ScopeNames.WITH_THUMBNAILS
+    ]).findAll(query)
   }
 
   static listAllAndSharedByActorForOutbox (actorId: number, start: number, count: number) {
@@ -892,12 +1013,12 @@ export class VideoModel extends Model<VideoModel> {
       distinct: true,
       offset: start,
       limit: count,
-      order: getVideoSort('createdAt', [ 'Tags', 'name', 'ASC' ]),
+      order: getVideoSort('createdAt', [ 'Tags', 'name', 'ASC' ] as any), // FIXME: sequelize typings
       where: {
         id: {
-          [ Sequelize.Op.in ]: Sequelize.literal('(' + rawQuery + ')')
+          [ Op.in ]: Sequelize.literal('(' + rawQuery + ')')
         },
-        [ Sequelize.Op.or ]: [
+        [ Op.or ]: [
           { privacy: VideoPrivacy.PUBLIC },
           { privacy: VideoPrivacy.UNLISTED }
         ]
@@ -914,10 +1035,10 @@ export class VideoModel extends Model<VideoModel> {
           required: false,
           // We only want videos shared by this actor
           where: {
-            [ Sequelize.Op.and ]: [
+            [ Op.and ]: [
               {
                 id: {
-                  [ Sequelize.Op.not ]: null
+                  [ Op.not ]: null
                 }
               },
               {
@@ -961,9 +1082,8 @@ export class VideoModel extends Model<VideoModel> {
     }
 
     return Bluebird.all([
-      // FIXME: typing issue
-      VideoModel.findAll(query as any),
-      VideoModel.sequelize.query(rawCountQuery, { type: Sequelize.QueryTypes.SELECT })
+      VideoModel.scope(ScopeNames.WITH_THUMBNAILS).findAll(query),
+      VideoModel.sequelize.query<{ total: string }>(rawCountQuery, { type: QueryTypes.SELECT })
     ]).then(([ rows, totals ]) => {
       // totals: totalVideos + totalVideoShares
       let totalVideos = 0
@@ -980,43 +1100,49 @@ export class VideoModel extends Model<VideoModel> {
   }
 
   static listUserVideosForApi (accountId: number, start: number, count: number, sort: string, withFiles = false) {
-    const query: IFindOptions<VideoModel> = {
-      offset: start,
-      limit: count,
-      order: getVideoSort(sort),
-      include: [
-        {
-          model: VideoChannelModel,
-          required: true,
-          include: [
-            {
-              model: AccountModel,
-              where: {
-                id: accountId
-              },
-              required: true
-            }
-          ]
-        },
-        {
-          model: ScheduleVideoUpdateModel,
-          required: false
-        },
-        {
-          model: VideoBlacklistModel,
-          required: false
-        }
-      ]
+    function buildBaseQuery (): FindOptions {
+      return {
+        offset: start,
+        limit: count,
+        order: getVideoSort(sort),
+        include: [
+          {
+            model: VideoChannelModel,
+            required: true,
+            include: [
+              {
+                model: AccountModel,
+                where: {
+                  id: accountId
+                },
+                required: true
+              }
+            ]
+          }
+        ]
+      }
     }
 
+    const countQuery = buildBaseQuery()
+    const findQuery = buildBaseQuery()
+
+    const findScopes = [
+      ScopeNames.WITH_SCHEDULED_UPDATE,
+      ScopeNames.WITH_BLACKLISTED,
+      ScopeNames.WITH_THUMBNAILS
+    ]
+
     if (withFiles === true) {
-      query.include.push({
+      findQuery.include.push({
         model: VideoFileModel.unscoped(),
         required: true
       })
     }
 
-    return VideoModel.findAndCountAll(query).then(({ rows, count }) => {
+    return Promise.all([
+      VideoModel.count(countQuery),
+      VideoModel.scope(findScopes).findAll(findQuery)
+    ]).then(([ count, rows ]) => {
       return {
         data: rows,
         total: count
@@ -1040,6 +1166,7 @@ export class VideoModel extends Model<VideoModel> {
     accountId?: number,
     videoChannelId?: number,
     followerActorId?: number
+    videoPlaylistId?: number,
     trendingDays?: number,
     user?: UserModel,
     historyOfUser?: UserModel
@@ -1048,7 +1175,7 @@ export class VideoModel extends Model<VideoModel> {
       throw new Error('Try to filter all-local but no user has not the see all videos right')
     }
 
-    const query: IFindOptions<VideoModel> = {
+    const query: FindOptions = {
       offset: options.start,
       limit: options.count,
       order: getVideoSort(options.sort)
@@ -1079,6 +1206,7 @@ export class VideoModel extends Model<VideoModel> {
       withFiles: options.withFiles,
       accountId: options.accountId,
       videoChannelId: options.videoChannelId,
+      videoPlaylistId: options.videoPlaylistId,
       includeLocalVideos: options.includeLocalVideos,
       user: options.user,
       historyOfUser: options.historyOfUser,
@@ -1096,6 +1224,8 @@ export class VideoModel extends Model<VideoModel> {
     sort?: string
     startDate?: string // ISO 8601
     endDate?: string // ISO 8601
+    originallyPublishedStartDate?: string
+    originallyPublishedEndDate?: string
     nsfw?: boolean
     categoryOneOf?: number[]
     licenceOneOf?: number[]
@@ -1112,17 +1242,26 @@ export class VideoModel extends Model<VideoModel> {
     if (options.startDate || options.endDate) {
       const publishedAtRange = {}
 
-      if (options.startDate) publishedAtRange[ Sequelize.Op.gte ] = options.startDate
-      if (options.endDate) publishedAtRange[ Sequelize.Op.lte ] = options.endDate
+      if (options.startDate) publishedAtRange[ Op.gte ] = options.startDate
+      if (options.endDate) publishedAtRange[ Op.lte ] = options.endDate
 
       whereAnd.push({ publishedAt: publishedAtRange })
     }
 
+    if (options.originallyPublishedStartDate || options.originallyPublishedEndDate) {
+      const originallyPublishedAtRange = {}
+
+      if (options.originallyPublishedStartDate) originallyPublishedAtRange[ Op.gte ] = options.originallyPublishedStartDate
+      if (options.originallyPublishedEndDate) originallyPublishedAtRange[ Op.lte ] = options.originallyPublishedEndDate
+
+      whereAnd.push({ originallyPublishedAt: originallyPublishedAtRange })
+    }
+
     if (options.durationMin || options.durationMax) {
       const durationRange = {}
 
-      if (options.durationMin) durationRange[ Sequelize.Op.gte ] = options.durationMin
-      if (options.durationMax) durationRange[ Sequelize.Op.lte ] = options.durationMax
+      if (options.durationMin) durationRange[ Op.gte ] = options.durationMin
+      if (options.durationMax) durationRange[ Op.lte ] = options.durationMax
 
       whereAnd.push({ duration: durationRange })
     }
@@ -1134,7 +1273,7 @@ export class VideoModel extends Model<VideoModel> {
       whereAnd.push(
         {
           id: {
-            [ Sequelize.Op.in ]: Sequelize.literal(
+            [ Op.in ]: Sequelize.literal(
               '(' +
               'SELECT "video"."id" FROM "video" ' +
               'WHERE ' +
@@ -1160,7 +1299,7 @@ export class VideoModel extends Model<VideoModel> {
       )
     }
 
-    const query: IFindOptions<VideoModel> = {
+    const query: FindOptions = {
       attributes: {
         include: attributesInclude
       },
@@ -1168,7 +1307,7 @@ export class VideoModel extends Model<VideoModel> {
       limit: options.count,
       order: getVideoSort(options.sort),
       where: {
-        [ Sequelize.Op.and ]: whereAnd
+        [ Op.and ]: whereAnd
       }
     }
 
@@ -1190,18 +1329,32 @@ export class VideoModel extends Model<VideoModel> {
     return VideoModel.getAvailableForApi(query, queryOptions)
   }
 
-  static load (id: number | string, t?: Sequelize.Transaction) {
-    const where = VideoModel.buildWhereIdOrUUID(id)
+  static load (id: number | string, t?: Transaction) {
+    const where = buildWhereIdOrUUID(id)
     const options = {
       where,
       transaction: t
     }
 
-    return VideoModel.findOne(options)
+    return VideoModel.scope(ScopeNames.WITH_THUMBNAILS).findOne(options)
   }
 
-  static loadOnlyId (id: number | string, t?: Sequelize.Transaction) {
-    const where = VideoModel.buildWhereIdOrUUID(id)
+  static loadWithRights (id: number | string, t?: Transaction) {
+    const where = buildWhereIdOrUUID(id)
+    const options = {
+      where,
+      transaction: t
+    }
+
+    return VideoModel.scope([
+      ScopeNames.WITH_BLACKLISTED,
+      ScopeNames.WITH_USER_ID,
+      ScopeNames.WITH_THUMBNAILS
+    ]).findOne(options)
+  }
+
+  static loadOnlyId (id: number | string, t?: Transaction) {
+    const where = buildWhereIdOrUUID(id)
 
     const options = {
       attributes: [ 'id' ],
@@ -1209,12 +1362,15 @@ export class VideoModel extends Model<VideoModel> {
       transaction: t
     }
 
-    return VideoModel.findOne(options)
+    return VideoModel.scope(ScopeNames.WITH_THUMBNAILS).findOne(options)
   }
 
-  static loadWithFile (id: number, t?: Sequelize.Transaction, logging?: boolean) {
-    return VideoModel.scope(ScopeNames.WITH_FILES)
-                     .findById(id, { transaction: t, logging })
+  static loadWithFiles (id: number, t?: Transaction, logging?: boolean) {
+    return VideoModel.scope([
+      ScopeNames.WITH_FILES,
+      ScopeNames.WITH_STREAMING_PLAYLISTS,
+      ScopeNames.WITH_THUMBNAILS
+    ]).findByPk(id, { transaction: t, logging })
   }
 
   static loadByUUIDWithFile (uuid: string) {
@@ -1224,52 +1380,85 @@ export class VideoModel extends Model<VideoModel> {
       }
     }
 
-    return VideoModel
-      .scope([ ScopeNames.WITH_FILES ])
-      .findOne(options)
+    return VideoModel.scope(ScopeNames.WITH_THUMBNAILS).findOne(options)
   }
 
-  static loadByUrl (url: string, transaction?: Sequelize.Transaction) {
-    const query: IFindOptions<VideoModel> = {
+  static loadByUrl (url: string, transaction?: Transaction) {
+    const query: FindOptions = {
       where: {
         url
       },
       transaction
     }
 
-    return VideoModel.findOne(query)
+    return VideoModel.scope(ScopeNames.WITH_THUMBNAILS).findOne(query)
   }
 
-  static loadByUrlAndPopulateAccount (url: string, transaction?: Sequelize.Transaction) {
-    const query: IFindOptions<VideoModel> = {
+  static loadByUrlAndPopulateAccount (url: string, transaction?: Transaction) {
+    const query: FindOptions = {
       where: {
         url
       },
       transaction
     }
 
-    return VideoModel.scope([ ScopeNames.WITH_ACCOUNT_DETAILS, ScopeNames.WITH_FILES ]).findOne(query)
+    return VideoModel.scope([
+      ScopeNames.WITH_ACCOUNT_DETAILS,
+      ScopeNames.WITH_FILES,
+      ScopeNames.WITH_STREAMING_PLAYLISTS,
+      ScopeNames.WITH_THUMBNAILS
+    ]).findOne(query)
   }
 
-  static loadAndPopulateAccountAndServerAndTags (id: number | string, t?: Sequelize.Transaction, userId?: number) {
-    const where = VideoModel.buildWhereIdOrUUID(id)
+  static loadAndPopulateAccountAndServerAndTags (id: number | string, t?: Transaction, userId?: number) {
+    const where = buildWhereIdOrUUID(id)
 
     const options = {
-      order: [ [ 'Tags', 'name', 'ASC' ] ],
+      order: [ [ 'Tags', 'name', 'ASC' ] ] as any,
       where,
       transaction: t
     }
 
-    const scopes = [
+    const scopes: (string | ScopeOptions)[] = [
       ScopeNames.WITH_TAGS,
       ScopeNames.WITH_BLACKLISTED,
+      ScopeNames.WITH_ACCOUNT_DETAILS,
+      ScopeNames.WITH_SCHEDULED_UPDATE,
       ScopeNames.WITH_FILES,
+      ScopeNames.WITH_STREAMING_PLAYLISTS,
+      ScopeNames.WITH_THUMBNAILS
+    ]
+
+    if (userId) {
+      scopes.push({ method: [ ScopeNames.WITH_USER_HISTORY, userId ] })
+    }
+
+    return VideoModel
+      .scope(scopes)
+      .findOne(options)
+  }
+
+  static loadForGetAPI (id: number | string, t?: Transaction, userId?: number) {
+    const where = buildWhereIdOrUUID(id)
+
+    const options = {
+      order: [ [ 'Tags', 'name', 'ASC' ] ] as any, // FIXME: sequelize typings
+      where,
+      transaction: t
+    }
+
+    const scopes: (string | ScopeOptions)[] = [
+      ScopeNames.WITH_TAGS,
+      ScopeNames.WITH_BLACKLISTED,
       ScopeNames.WITH_ACCOUNT_DETAILS,
-      ScopeNames.WITH_SCHEDULED_UPDATE
+      ScopeNames.WITH_SCHEDULED_UPDATE,
+      ScopeNames.WITH_THUMBNAILS,
+      { method: [ ScopeNames.WITH_FILES, true ] },
+      { method: [ ScopeNames.WITH_STREAMING_PLAYLISTS, true ] }
     ]
 
     if (userId) {
-      scopes.push({ method: [ ScopeNames.WITH_USER_HISTORY, userId ] } as any) // FIXME: typings
+      scopes.push({ method: [ ScopeNames.WITH_USER_HISTORY, userId ] })
     }
 
     return VideoModel
@@ -1317,7 +1506,7 @@ export class VideoModel extends Model<VideoModel> {
     'LIMIT 1'
 
     const options = {
-      type: Sequelize.QueryTypes.SELECT,
+      type: QueryTypes.SELECT,
       bind: { followerActorId, videoId },
       raw: true
     }
@@ -1334,17 +1523,18 @@ export class VideoModel extends Model<VideoModel> {
     const scopeOptions: AvailableForListIDsOptions = {
       serverAccountId: serverActor.Account.id,
       followerActorId,
-      includeLocalVideos: true
+      includeLocalVideos: true,
+      withoutId: true // Don't break aggregation
     }
 
-    const query: IFindOptions<VideoModel> = {
+    const query: FindOptions = {
       attributes: [ field ],
       limit: count,
       group: field,
-      having: Sequelize.where(Sequelize.fn('COUNT', Sequelize.col(field)), {
-        [ Sequelize.Op.gte ]: threshold
-      }) as any, // FIXME: typings
-      order: [ this.sequelize.random() ]
+      having: Sequelize.where(
+        Sequelize.fn('COUNT', Sequelize.col(field)), { [ Op.gte ]: threshold }
+      ),
+      order: [ (this.sequelize as any).random() ]
     }
 
     return VideoModel.scope({ method: [ ScopeNames.AVAILABLE_FOR_LIST_IDS, scopeOptions ] })
@@ -1360,7 +1550,7 @@ export class VideoModel extends Model<VideoModel> {
       required: false,
       where: {
         startDate: {
-          [ Sequelize.Op.gte ]: new Date(new Date().getTime() - (24 * 3600 * 1000) * trendingDays)
+          [ Op.gte ]: new Date(new Date().getTime() - (24 * 3600 * 1000) * trendingDays)
         }
       }
     }
@@ -1377,11 +1567,11 @@ export class VideoModel extends Model<VideoModel> {
   }
 
   private static async getAvailableForApi (
-    query: IFindOptions<VideoModel>,
+    query: FindOptions,
     options: AvailableForListIDsOptions,
     countVideos = true
   ) {
-    const idsScope = {
+    const idsScope: ScopeOptions = {
       method: [
         ScopeNames.AVAILABLE_FOR_LIST_IDS, options
       ]
@@ -1389,8 +1579,8 @@ export class VideoModel extends Model<VideoModel> {
 
     // Remove trending sort on count, because it uses a group by
     const countOptions = Object.assign({}, options, { trendingDays: undefined })
-    const countQuery = Object.assign({}, query, { attributes: undefined, group: undefined })
-    const countScope = {
+    const countQuery: CountOptions = Object.assign({}, query, { attributes: undefined, group: undefined })
+    const countScope: ScopeOptions = {
       method: [
         ScopeNames.AVAILABLE_FOR_LIST_IDS, countOptions
       ]
@@ -1404,18 +1594,7 @@ export class VideoModel extends Model<VideoModel> {
 
     if (ids.length === 0) return { data: [], total: count }
 
-    // FIXME: typings
-    const apiScope: any[] = [
-      {
-        method: [ ScopeNames.FOR_API, { ids, withFiles: options.withFiles } as ForAPIOptions ]
-      }
-    ]
-
-    if (options.user) {
-      apiScope.push({ method: [ ScopeNames.WITH_USER_HISTORY, options.user.id ] })
-    }
-
-    const secondQuery = {
+    const secondQuery: FindOptions = {
       offset: 0,
       limit: query.limit,
       attributes: query.attributes,
@@ -1425,6 +1604,23 @@ export class VideoModel extends Model<VideoModel> {
         )
       ]
     }
+
+    const apiScope: (string | ScopeOptions)[] = []
+
+    if (options.user) {
+      apiScope.push({ method: [ ScopeNames.WITH_USER_HISTORY, options.user.id ] })
+    }
+
+    apiScope.push({
+      method: [
+        ScopeNames.FOR_API, {
+          ids,
+          withFiles: options.withFiles,
+          videoPlaylistId: options.videoPlaylistId
+        } as ForAPIOptions
+      ]
+    })
+
     const rows = await VideoModel.scope(apiScope).findAll(secondQuery)
 
     return {
@@ -1453,10 +1649,6 @@ export class VideoModel extends Model<VideoModel> {
     return VIDEO_STATES[ id ] || 'Unknown'
   }
 
-  static buildWhereIdOrUUID (id: number | string) {
-    return validator.isInt('' + id) ? { id } : { uuid: id }
-  }
-
   getOriginalFile () {
     if (Array.isArray(this.VideoFiles) === false) return undefined
 
@@ -1464,19 +1656,41 @@ export class VideoModel extends Model<VideoModel> {
     return maxBy(this.VideoFiles, file => file.resolution)
   }
 
+  async addAndSaveThumbnail (thumbnail: ThumbnailModel, transaction: Transaction) {
+    thumbnail.videoId = this.id
+
+    const savedThumbnail = await thumbnail.save({ transaction })
+
+    if (Array.isArray(this.Thumbnails) === false) this.Thumbnails = []
+
+    // Already have this thumbnail, skip
+    if (this.Thumbnails.find(t => t.id === savedThumbnail.id)) return
+
+    this.Thumbnails.push(savedThumbnail)
+  }
+
   getVideoFilename (videoFile: VideoFileModel) {
     return this.uuid + '-' + videoFile.resolution + videoFile.extname
   }
 
-  getThumbnailName () {
-    // We always have a copy of the thumbnail
-    const extension = '.jpg'
-    return this.uuid + extension
+  generateThumbnailName () {
+    return this.uuid + '.jpg'
   }
 
-  getPreviewName () {
-    const extension = '.jpg'
-    return this.uuid + extension
+  getMiniature () {
+    if (Array.isArray(this.Thumbnails) === false) return undefined
+
+    return this.Thumbnails.find(t => t.type === ThumbnailType.MINIATURE)
+  }
+
+  generatePreviewName () {
+    return this.uuid + '.jpg'
+  }
+
+  getPreview () {
+    if (Array.isArray(this.Thumbnails) === false) return undefined
+
+    return this.Thumbnails.find(t => t.type === ThumbnailType.PREVIEW)
   }
 
   getTorrentFileName (videoFile: VideoFileModel) {
@@ -1488,24 +1702,6 @@ export class VideoModel extends Model<VideoModel> {
     return this.remote === false
   }
 
-  createPreview (videoFile: VideoFileModel) {
-    return generateImageFromVideoFile(
-      this.getVideoFilePath(videoFile),
-      CONFIG.STORAGE.PREVIEWS_DIR,
-      this.getPreviewName(),
-      PREVIEWS_SIZE
-    )
-  }
-
-  createThumbnail (videoFile: VideoFileModel) {
-    return generateImageFromVideoFile(
-      this.getVideoFilePath(videoFile),
-      CONFIG.STORAGE.THUMBNAILS_DIR,
-      this.getThumbnailName(),
-      THUMBNAILS_SIZE
-    )
-  }
-
   getTorrentFilePath (videoFile: VideoFileModel) {
     return join(CONFIG.STORAGE.TORRENTS_DIR, this.getTorrentFileName(videoFile))
   }
@@ -1520,10 +1716,10 @@ export class VideoModel extends Model<VideoModel> {
       name: `${this.name} ${videoFile.resolution}p${videoFile.extname}`,
       createdBy: 'PeerTube',
       announceList: [
-        [ CONFIG.WEBSERVER.WS + '://' + CONFIG.WEBSERVER.HOSTNAME + ':' + CONFIG.WEBSERVER.PORT + '/tracker/socket' ],
-        [ CONFIG.WEBSERVER.URL + '/tracker/announce' ]
+        [ WEBSERVER.WS + '://' + WEBSERVER.HOSTNAME + ':' + WEBSERVER.PORT + '/tracker/socket' ],
+        [ WEBSERVER.URL + '/tracker/announce' ]
       ],
-      urlList: [ CONFIG.WEBSERVER.URL + STATIC_PATHS.WEBSEED + this.getVideoFilename(videoFile) ]
+      urlList: [ WEBSERVER.URL + STATIC_PATHS.WEBSEED + this.getVideoFilename(videoFile) ]
     }
 
     const torrent = await createTorrentPromise(this.getVideoFilePath(videoFile), options)
@@ -1545,12 +1741,19 @@ export class VideoModel extends Model<VideoModel> {
     return '/videos/embed/' + this.uuid
   }
 
-  getThumbnailStaticPath () {
-    return join(STATIC_PATHS.THUMBNAILS, this.getThumbnailName())
+  getMiniatureStaticPath () {
+    const thumbnail = this.getMiniature()
+    if (!thumbnail) return null
+
+    return join(STATIC_PATHS.THUMBNAILS, thumbnail.filename)
   }
 
   getPreviewStaticPath () {
-    return join(STATIC_PATHS.PREVIEWS, this.getPreviewName())
+    const preview = this.getPreview()
+    if (!preview) return null
+
+    // We use a local cache, so specify our cache endpoint instead of potential remote URL
+    return join(STATIC_PATHS.PREVIEWS, preview.filename)
   }
 
   toFormattedJSON (options?: VideoFormattingJSONOptions): Video {
@@ -1586,18 +1789,6 @@ export class VideoModel extends Model<VideoModel> {
     return `/api/${API_VERSION}/videos/${this.uuid}/description`
   }
 
-  removeThumbnail () {
-    const thumbnailPath = join(CONFIG.STORAGE.THUMBNAILS_DIR, this.getThumbnailName())
-    return remove(thumbnailPath)
-      .catch(err => logger.warn('Cannot delete thumbnail %s.', thumbnailPath, { err }))
-  }
-
-  removePreview () {
-    const previewPath = join(CONFIG.STORAGE.PREVIEWS_DIR + this.getPreviewName())
-    return remove(previewPath)
-      .catch(err => logger.warn('Cannot delete preview %s.', previewPath, { err }))
-  }
-
   removeFile (videoFile: VideoFileModel, isRedundancy = false) {
     const baseDir = isRedundancy ? CONFIG.STORAGE.REDUNDANCY_DIR : CONFIG.STORAGE.VIDEOS_DIR
 
@@ -1612,15 +1803,18 @@ export class VideoModel extends Model<VideoModel> {
       .catch(err => logger.warn('Cannot delete torrent %s.', torrentPath, { err }))
   }
 
+  removeStreamingPlaylist (isRedundancy = false) {
+    const baseDir = isRedundancy ? HLS_REDUNDANCY_DIRECTORY : HLS_STREAMING_PLAYLIST_DIRECTORY
+
+    const filePath = join(baseDir, this.uuid)
+    return remove(filePath)
+      .catch(err => logger.warn('Cannot delete playlist directory %s.', filePath, { err }))
+  }
+
   isOutdated () {
     if (this.isOwned()) return false
 
-    const now = Date.now()
-    const createdAtTime = this.createdAt.getTime()
-    const updatedAtTime = this.updatedAt.getTime()
-
-    return (now - createdAtTime) > ACTIVITY_PUB.VIDEO_REFRESH_INTERVAL &&
-      (now - updatedAtTime) > ACTIVITY_PUB.VIDEO_REFRESH_INTERVAL
+    return isOutdated(this, ACTIVITY_PUB.VIDEO_REFRESH_INTERVAL)
   }
 
   setAsRefreshed () {
@@ -1634,8 +1828,8 @@ export class VideoModel extends Model<VideoModel> {
     let baseUrlWs
 
     if (this.isOwned()) {
-      baseUrlHttp = CONFIG.WEBSERVER.URL
-      baseUrlWs = CONFIG.WEBSERVER.WS + '://' + CONFIG.WEBSERVER.HOSTNAME + ':' + CONFIG.WEBSERVER.PORT
+      baseUrlHttp = WEBSERVER.URL
+      baseUrlWs = WEBSERVER.WS + '://' + WEBSERVER.HOSTNAME + ':' + WEBSERVER.PORT
     } else {
       baseUrlHttp = REMOTE_SCHEME.HTTP + '://' + this.VideoChannel.Account.Actor.Server.host
       baseUrlWs = REMOTE_SCHEME.WS + '://' + this.VideoChannel.Account.Actor.Server.host
@@ -1646,7 +1840,7 @@ export class VideoModel extends Model<VideoModel> {
 
   generateMagnetUri (videoFile: VideoFileModel, baseUrlHttp: string, baseUrlWs: string) {
     const xs = this.getTorrentUrl(videoFile, baseUrlHttp)
-    const announce = [ baseUrlWs + '/tracker/socket', baseUrlHttp + '/tracker/announce' ]
+    const announce = this.getTrackerUrls(baseUrlHttp, baseUrlWs)
     let urlList = [ this.getVideoFileUrl(videoFile, baseUrlHttp) ]
 
     const redundancies = videoFile.RedundancyVideos
@@ -1663,8 +1857,8 @@ export class VideoModel extends Model<VideoModel> {
     return magnetUtil.encode(magnetHash)
   }
 
-  getThumbnailUrl (baseUrlHttp: string) {
-    return baseUrlHttp + STATIC_PATHS.THUMBNAILS + this.getThumbnailName()
+  getTrackerUrls (baseUrlHttp: string, baseUrlWs: string) {
+    return [ baseUrlWs + '/tracker/socket', baseUrlHttp + '/tracker/announce' ]
   }
 
   getTorrentUrl (videoFile: VideoFileModel, baseUrlHttp: string) {
@@ -1686,4 +1880,8 @@ export class VideoModel extends Model<VideoModel> {
   getVideoFileDownloadUrl (videoFile: VideoFileModel, baseUrlHttp: string) {
     return baseUrlHttp + STATIC_DOWNLOAD_PATHS.VIDEOS + this.getVideoFilename(videoFile)
   }
+
+  getBandwidthBits (videoFile: VideoFileModel) {
+    return Math.ceil((videoFile.size * 8) / this.duration)
+  }
 }
diff --git a/server/tests/api/activitypub/client.ts b/server/tests/api/activitypub/client.ts
index 6d90d8643..edf588c16 100644
--- a/server/tests/api/activitypub/client.ts
+++ b/server/tests/api/activitypub/client.ts
@@ -11,7 +11,7 @@ import {
   ServerInfo,
   setAccessTokensToServers,
   uploadVideo
-} from '../../../../shared/utils'
+} from '../../../../shared/extra-utils'
 
 const expect = chai.expect
 
@@ -22,8 +22,6 @@ describe('Test activitypub', function () {
   before(async function () {
     this.timeout(30000)
 
-    await flushTests()
-
     servers = await flushAndRunMultipleServers(2)
 
     await setAccessTokensToServers(servers)
@@ -61,7 +59,7 @@ describe('Test activitypub', function () {
     expect(res.header.location).to.equal('http://localhost:9001/videos/watch/' + videoUUID)
   })
 
-  after(async function () {
+  after(function () {
     killallServers(servers)
   })
 })
diff --git a/server/tests/api/activitypub/fetch.ts b/server/tests/api/activitypub/fetch.ts
index 03609c1a9..7240bb0fb 100644
--- a/server/tests/api/activitypub/fetch.ts
+++ b/server/tests/api/activitypub/fetch.ts
@@ -3,6 +3,7 @@
 import 'mocha'
 
 import {
+  closeAllSequelize,
   createUser,
   doubleFollow,
   flushAndRunMultipleServers,
@@ -16,7 +17,7 @@ import {
   uploadVideo,
   userLogin,
   waitJobs
-} from '../../../../shared/utils'
+} from '../../../../shared/extra-utils'
 import * as chai from 'chai'
 import { Video } from '../../../../shared/models/videos'
 
@@ -37,7 +38,7 @@ describe('Test ActivityPub fetcher', function () {
 
     const user = { username: 'user1', password: 'password' }
     for (const server of servers) {
-      await createUser(server.url, server.accessToken, user.username, user.password)
+      await createUser({ url: server.url, accessToken: server.accessToken, username: user.username, password: user.password })
     }
 
     const userAccessToken = await userLogin(servers[0], user)
@@ -79,9 +80,6 @@ describe('Test ActivityPub fetcher', function () {
   after(async function () {
     killallServers(servers)
 
-    // Keep the logs if the test failed
-    if (this['ok']) {
-      await flushTests()
-    }
+    await closeAllSequelize(servers)
   })
 })
diff --git a/server/tests/api/activitypub/helpers.ts b/server/tests/api/activitypub/helpers.ts
index ac6e755c3..365d0e1ae 100644
--- a/server/tests/api/activitypub/helpers.ts
+++ b/server/tests/api/activitypub/helpers.ts
@@ -2,7 +2,7 @@
 
 import 'mocha'
 import { expect } from 'chai'
-import { buildRequestStub } from '../../../../shared/utils/miscs/stubs'
+import { buildRequestStub } from '../../../../shared/extra-utils/miscs/stubs'
 import { isHTTPSignatureVerified, isJsonLDSignatureVerified, parseHTTPSignature } from '../../../helpers/peertube-crypto'
 import { cloneDeep } from 'lodash'
 import { buildSignedActivity } from '../../../helpers/activitypub'
diff --git a/server/tests/api/activitypub/index.ts b/server/tests/api/activitypub/index.ts
index 450053309..92bd6f660 100644
--- a/server/tests/api/activitypub/index.ts
+++ b/server/tests/api/activitypub/index.ts
@@ -1,5 +1,5 @@
 import './client'
 import './fetch'
-import './helpers'
 import './refresher'
+import './helpers'
 import './security'
diff --git a/server/tests/api/activitypub/refresher.ts b/server/tests/api/activitypub/refresher.ts
index 62ad8a0b5..9be9aa495 100644
--- a/server/tests/api/activitypub/refresher.ts
+++ b/server/tests/api/activitypub/refresher.ts
@@ -2,92 +2,158 @@
 
 import 'mocha'
 import {
+  createVideoPlaylist,
   doubleFollow,
   flushAndRunMultipleServers,
+  generateUserAccessToken,
   getVideo,
-  killallServers,
+  getVideoPlaylist,
+  killallServers, rateVideo,
   reRunServer,
   ServerInfo,
   setAccessTokensToServers,
+  setActorField,
+  setDefaultVideoChannel,
+  setPlaylistField,
+  setVideoField,
   uploadVideo,
+  uploadVideoAndGetId,
   wait,
-  setVideoField,
   waitJobs
-} from '../../../../shared/utils'
+} from '../../../../shared/extra-utils'
+import { getAccount } from '../../../../shared/extra-utils/users/accounts'
+import { VideoPlaylistPrivacy } from '../../../../shared/models/videos'
 
 describe('Test AP refresher', function () {
   let servers: ServerInfo[] = []
   let videoUUID1: string
   let videoUUID2: string
   let videoUUID3: string
+  let playlistUUID1: string
+  let playlistUUID2: string
 
   before(async function () {
     this.timeout(60000)
 
-    servers = await flushAndRunMultipleServers(2)
+    servers = await flushAndRunMultipleServers(2, { transcoding: { enabled: false } })
 
     // Get the access tokens
     await setAccessTokensToServers(servers)
+    await setDefaultVideoChannel(servers)
+
+    {
+      videoUUID1 = (await uploadVideoAndGetId({ server: servers[ 1 ], videoName: 'video1' })).uuid
+      videoUUID2 = (await uploadVideoAndGetId({ server: servers[ 1 ], videoName: 'video2' })).uuid
+      videoUUID3 = (await uploadVideoAndGetId({ server: servers[ 1 ], videoName: 'video3' })).uuid
+    }
 
     {
-      const res = await uploadVideo(servers[1].url, servers[1].accessToken, { name: 'video1' })
-      videoUUID1 = res.body.video.uuid
+      const a1 = await generateUserAccessToken(servers[1], 'user1')
+      await uploadVideo(servers[1].url, a1, { name: 'video4' })
+
+      const a2 = await generateUserAccessToken(servers[1], 'user2')
+      await uploadVideo(servers[1].url, a2, { name: 'video5' })
     }
 
     {
-      const res = await uploadVideo(servers[1].url, servers[1].accessToken, { name: 'video2' })
-      videoUUID2 = res.body.video.uuid
+      const playlistAttrs = { displayName: 'playlist1', privacy: VideoPlaylistPrivacy.PUBLIC, videoChannelId: servers[1].videoChannel.id }
+      const res = await createVideoPlaylist({ url: servers[1].url, token: servers[1].accessToken, playlistAttrs })
+      playlistUUID1 = res.body.videoPlaylist.uuid
     }
 
     {
-      const res = await uploadVideo(servers[1].url, servers[1].accessToken, { name: 'video3' })
-      videoUUID3 = res.body.video.uuid
+      const playlistAttrs = { displayName: 'playlist2', privacy: VideoPlaylistPrivacy.PUBLIC, videoChannelId: servers[1].videoChannel.id }
+      const res = await createVideoPlaylist({ url: servers[1].url, token: servers[1].accessToken, playlistAttrs })
+      playlistUUID2 = res.body.videoPlaylist.uuid
     }
 
     await doubleFollow(servers[0], servers[1])
   })
 
-  it('Should remove a deleted remote video', async function () {
-    this.timeout(60000)
+  describe('Videos refresher', function () {
+
+    it('Should remove a deleted remote video', async function () {
+      this.timeout(60000)
+
+      await wait(10000)
+
+      // Change UUID so the remote server returns a 404
+      await setVideoField(2, videoUUID1, 'uuid', '304afe4f-39f9-4d49-8ed7-ac57b86b174f')
+
+      await getVideo(servers[ 0 ].url, videoUUID1)
+      await getVideo(servers[ 0 ].url, videoUUID2)
+
+      await waitJobs(servers)
 
-    await wait(10000)
+      await getVideo(servers[ 0 ].url, videoUUID1, 404)
+      await getVideo(servers[ 0 ].url, videoUUID2, 200)
+    })
 
-    // Change UUID so the remote server returns a 404
-    await setVideoField(2, videoUUID1, 'uuid', '304afe4f-39f9-4d49-8ed7-ac57b86b174f')
+    it('Should not update a remote video if the remote instance is down', async function () {
+      this.timeout(60000)
 
-    await getVideo(servers[0].url, videoUUID1)
-    await getVideo(servers[0].url, videoUUID2)
+      killallServers([ servers[ 1 ] ])
 
-    await waitJobs(servers)
+      await setVideoField(2, videoUUID3, 'uuid', '304afe4f-39f9-4d49-8ed7-ac57b86b174e')
 
-    await getVideo(servers[0].url, videoUUID1, 404)
-    await getVideo(servers[0].url, videoUUID2, 200)
+      // Video will need a refresh
+      await wait(10000)
+
+      await getVideo(servers[ 0 ].url, videoUUID3)
+      // The refresh should fail
+      await waitJobs([ servers[ 0 ] ])
+
+      await reRunServer(servers[ 1 ])
+
+      // Should not refresh the video, even if the last refresh failed (to avoir a loop on dead instances)
+      await getVideo(servers[ 0 ].url, videoUUID3)
+      await waitJobs(servers)
+
+      await getVideo(servers[ 0 ].url, videoUUID3, 200)
+    })
   })
 
-  it('Should not update a remote video if the remote instance is down', async function () {
-    this.timeout(60000)
+  describe('Actors refresher', function () {
+
+    it('Should remove a deleted actor', async function () {
+      this.timeout(60000)
+
+      await wait(10000)
+
+      // Change actor name so the remote server returns a 404
+      await setActorField(2, 'http://localhost:9002/accounts/user2', 'preferredUsername', 'toto')
+
+      await getAccount(servers[ 0 ].url, 'user1@localhost:9002')
+      await getAccount(servers[ 0 ].url, 'user2@localhost:9002')
+
+      await waitJobs(servers)
+
+      await getAccount(servers[ 0 ].url, 'user1@localhost:9002', 200)
+      await getAccount(servers[ 0 ].url, 'user2@localhost:9002', 404)
+    })
+  })
 
-    killallServers([ servers[1] ])
+  describe('Playlist refresher', function () {
 
-    await setVideoField(2, videoUUID3, 'uuid', '304afe4f-39f9-4d49-8ed7-ac57b86b174e')
+    it('Should remove a deleted playlist', async function () {
+      this.timeout(60000)
 
-    // Video will need a refresh
-    await wait(10000)
+      await wait(10000)
 
-    await getVideo(servers[0].url, videoUUID3)
-    // The refresh should fail
-    await waitJobs([ servers[0] ])
+      // Change UUID so the remote server returns a 404
+      await setPlaylistField(2, playlistUUID2, 'uuid', '304afe4f-39f9-4d49-8ed7-ac57b86b178e')
 
-    await reRunServer(servers[1])
+      await getVideoPlaylist(servers[ 0 ].url, playlistUUID1)
+      await getVideoPlaylist(servers[ 0 ].url, playlistUUID2)
 
-    // Should not refresh the video, even if the last refresh failed (to avoir a loop on dead instances)
-    await getVideo(servers[0].url, videoUUID3)
-    await waitJobs(servers)
+      await waitJobs(servers)
 
-    await getVideo(servers[0].url, videoUUID3, 200)
+      await getVideoPlaylist(servers[ 0 ].url, playlistUUID1, 200)
+      await getVideoPlaylist(servers[ 0 ].url, playlistUUID2, 404)
+    })
   })
 
-  after(async function () {
+  after(function () {
     killallServers(servers)
   })
 })
diff --git a/server/tests/api/activitypub/security.ts b/server/tests/api/activitypub/security.ts
index 342ae0fa1..11e6859bf 100644
--- a/server/tests/api/activitypub/security.ts
+++ b/server/tests/api/activitypub/security.ts
@@ -3,18 +3,18 @@
 import 'mocha'
 
 import {
+  closeAllSequelize,
   flushAndRunMultipleServers,
   flushTests,
   killallServers,
-  makeFollowRequest,
-  makePOSTAPRequest,
   ServerInfo,
   setActorField
-} from '../../../../shared/utils'
-import { HTTP_SIGNATURE } from '../../../initializers'
+} from '../../../../shared/extra-utils'
+import { HTTP_SIGNATURE } from '../../../initializers/constants'
 import { buildDigest, buildGlobalHeaders } from '../../../lib/job-queue/handlers/utils/activitypub-http-utils'
 import * as chai from 'chai'
 import { activityPubContextify, buildSignedActivity } from '../../../helpers/activitypub'
+import { makeFollowRequest, makePOSTAPRequest } from '../../../../shared/extra-utils/requests/activitypub'
 
 const expect = chai.expect
 
@@ -179,9 +179,6 @@ describe('Test ActivityPub security', function () {
   after(async function () {
     killallServers(servers)
 
-    // Keep the logs if the test failed
-    if (this['ok']) {
-      await flushTests()
-    }
+    await closeAllSequelize(servers)
   })
 })
diff --git a/server/tests/api/check-params/accounts.ts b/server/tests/api/check-params/accounts.ts
index 68f9519c6..4f79685bd 100644
--- a/server/tests/api/check-params/accounts.ts
+++ b/server/tests/api/check-params/accounts.ts
@@ -2,13 +2,13 @@
 
 import 'mocha'
 
-import { flushTests, killallServers, runServer, ServerInfo } from '../../../../shared/utils'
+import { cleanupTests, flushAndRunServer, ServerInfo } from '../../../../shared/extra-utils'
 import {
   checkBadCountPagination,
   checkBadSortPagination,
   checkBadStartPagination
-} from '../../../../shared/utils/requests/check-api-params'
-import { getAccount } from '../../../../shared/utils/users/accounts'
+} from '../../../../shared/extra-utils/requests/check-api-params'
+import { getAccount } from '../../../../shared/extra-utils/users/accounts'
 
 describe('Test accounts API validators', function () {
   const path = '/api/v1/accounts/'
@@ -19,9 +19,7 @@ describe('Test accounts API validators', function () {
   before(async function () {
     this.timeout(30000)
 
-    await flushTests()
-
-    server = await runServer(1)
+    server = await flushAndRunServer(1)
   })
 
   describe('When listing accounts', function () {
@@ -45,11 +43,6 @@ describe('Test accounts API validators', function () {
   })
 
   after(async function () {
-    killallServers([ server ])
-
-    // Keep the logs if the test failed
-    if (this['ok']) {
-      await flushTests()
-    }
+    await cleanupTests([ server ])
   })
 })
diff --git a/server/tests/api/check-params/blocklist.ts b/server/tests/api/check-params/blocklist.ts
index c20453c16..0661676ce 100644
--- a/server/tests/api/check-params/blocklist.ts
+++ b/server/tests/api/check-params/blocklist.ts
@@ -3,22 +3,22 @@
 import 'mocha'
 
 import {
+  cleanupTests,
   createUser,
   doubleFollow,
   flushAndRunMultipleServers,
-  flushTests,
-  killallServers,
   makeDeleteRequest,
   makeGetRequest,
   makePostBodyRequest,
   ServerInfo,
-  setAccessTokensToServers, userLogin
-} from '../../../../shared/utils'
+  setAccessTokensToServers,
+  userLogin
+} from '../../../../shared/extra-utils'
 import {
   checkBadCountPagination,
   checkBadSortPagination,
   checkBadStartPagination
-} from '../../../../shared/utils/requests/check-api-params'
+} from '../../../../shared/extra-utils/requests/check-api-params'
 
 describe('Test blocklist API validators', function () {
   let servers: ServerInfo[]
@@ -28,15 +28,13 @@ describe('Test blocklist API validators', function () {
   before(async function () {
     this.timeout(60000)
 
-    await flushTests()
-
     servers = await flushAndRunMultipleServers(2)
     await setAccessTokensToServers(servers)
 
     server = servers[0]
 
     const user = { username: 'user1', password: 'password' }
-    await createUser(server.url, server.accessToken, user.username, user.password)
+    await createUser({ url: server.url, accessToken: server.accessToken, username: user.username, password: user.password })
 
     userAccessToken = await userLogin(server, user)
 
@@ -192,7 +190,7 @@ describe('Test blocklist API validators', function () {
             url: server.url,
             token: server.accessToken,
             path,
-            fields: { host: 'localhost:9001' },
+            fields: { host: 'localhost:' + server.port },
             statusCodeExpected: 409
           })
         })
@@ -202,7 +200,7 @@ describe('Test blocklist API validators', function () {
             url: server.url,
             token: server.accessToken,
             path,
-            fields: { host: 'localhost:9002' },
+            fields: { host: 'localhost:' + servers[1].port },
             statusCodeExpected: 204
           })
         })
@@ -212,7 +210,7 @@ describe('Test blocklist API validators', function () {
         it('Should fail with an unauthenticated user', async function () {
           await makeDeleteRequest({
             url: server.url,
-            path: path + '/localhost:9002',
+            path: path + '/localhost:' + servers[1].port,
             statusCodeExpected: 401
           })
         })
@@ -229,7 +227,7 @@ describe('Test blocklist API validators', function () {
         it('Should succeed with the correct params', async function () {
           await makeDeleteRequest({
             url: server.url,
-            path: path + '/localhost:9002',
+            path: path + '/localhost:' + servers[1].port,
             token: server.accessToken,
             statusCodeExpected: 204
           })
@@ -402,7 +400,7 @@ describe('Test blocklist API validators', function () {
           await makePostBodyRequest({
             url: server.url,
             path,
-            fields: { host: 'localhost:9002' },
+            fields: { host: 'localhost:' + servers[1].port },
             statusCodeExpected: 401
           })
         })
@@ -412,7 +410,7 @@ describe('Test blocklist API validators', function () {
             url: server.url,
             token: userAccessToken,
             path,
-            fields: { host: 'localhost:9002' },
+            fields: { host: 'localhost:' + servers[1].port },
             statusCodeExpected: 403
           })
         })
@@ -432,7 +430,7 @@ describe('Test blocklist API validators', function () {
             url: server.url,
             token: server.accessToken,
             path,
-            fields: { host: 'localhost:9001' },
+            fields: { host: 'localhost:' + server.port },
             statusCodeExpected: 409
           })
         })
@@ -442,7 +440,7 @@ describe('Test blocklist API validators', function () {
             url: server.url,
             token: server.accessToken,
             path,
-            fields: { host: 'localhost:9002' },
+            fields: { host: 'localhost:' + servers[1].port },
             statusCodeExpected: 204
           })
         })
@@ -452,7 +450,7 @@ describe('Test blocklist API validators', function () {
         it('Should fail with an unauthenticated user', async function () {
           await makeDeleteRequest({
             url: server.url,
-            path: path + '/localhost:9002',
+            path: path + '/localhost:' + servers[1].port,
             statusCodeExpected: 401
           })
         })
@@ -460,7 +458,7 @@ describe('Test blocklist API validators', function () {
         it('Should fail with a user without the appropriate rights', async function () {
           await makeDeleteRequest({
             url: server.url,
-            path: path + '/localhost:9002',
+            path: path + '/localhost:' + servers[1].port,
             token: userAccessToken,
             statusCodeExpected: 403
           })
@@ -478,7 +476,7 @@ describe('Test blocklist API validators', function () {
         it('Should succeed with the correct params', async function () {
           await makeDeleteRequest({
             url: server.url,
-            path: path + '/localhost:9002',
+            path: path + '/localhost:' + servers[1].port,
             token: server.accessToken,
             statusCodeExpected: 204
           })
@@ -488,11 +486,6 @@ describe('Test blocklist API validators', function () {
   })
 
   after(async function () {
-    killallServers(servers)
-
-    // Keep the logs if the test failed
-    if (this['ok']) {
-      await flushTests()
-    }
+    await cleanupTests(servers)
   })
 })
diff --git a/server/tests/api/check-params/config.ts b/server/tests/api/check-params/config.ts
index 4038ecbf0..2a2ec606a 100644
--- a/server/tests/api/check-params/config.ts
+++ b/server/tests/api/check-params/config.ts
@@ -5,9 +5,9 @@ import 'mocha'
 import { CustomConfig } from '../../../../shared/models/server/custom-config.model'
 
 import {
-  createUser, flushTests, killallServers, makeDeleteRequest, makeGetRequest, makePutBodyRequest, runServer, ServerInfo,
-  setAccessTokensToServers, userLogin, immutableAssign
-} from '../../../../shared/utils'
+  createUser, flushTests, killallServers, makeDeleteRequest, makeGetRequest, makePutBodyRequest, flushAndRunServer, ServerInfo,
+  setAccessTokensToServers, userLogin, immutableAssign, cleanupTests
+} from '../../../../shared/extra-utils'
 
 describe('Test config API validators', function () {
   const path = '/api/v1/config/custom'
@@ -19,6 +19,7 @@ describe('Test config API validators', function () {
       shortDescription: 'my short description',
       description: 'my super description',
       terms: 'my super terms',
+      isNSFW: true,
       defaultClientRoute: '/videos/recently-added',
       defaultNSFWPolicy: 'blur',
       customizations: {
@@ -65,6 +66,9 @@ describe('Test config API validators', function () {
         '480p': true,
         '720p': false,
         '1080p': false
+      },
+      hls: {
+        enabled: false
       }
     },
     import: {
@@ -76,6 +80,19 @@ describe('Test config API validators', function () {
           enabled: false
         }
       }
+    },
+    autoBlacklist: {
+      videos: {
+        ofUsers: {
+          enabled: false
+        }
+      }
+    },
+    followers: {
+      instance: {
+        enabled: false,
+        manualApproval: true
+      }
     }
   }
 
@@ -84,8 +101,7 @@ describe('Test config API validators', function () {
   before(async function () {
     this.timeout(30000)
 
-    await flushTests()
-    server = await runServer(1)
+    server = await flushAndRunServer(1)
 
     await setAccessTokensToServers([ server ])
 
@@ -93,7 +109,7 @@ describe('Test config API validators', function () {
       username: 'user1',
       password: 'password'
     }
-    await createUser(server.url, server.accessToken, user.username, user.password)
+    await createUser({ url: server.url, accessToken: server.accessToken, username: user.username, password: user.password })
     userAccessToken = await userLogin(server, user)
   })
 
@@ -164,6 +180,25 @@ describe('Test config API validators', function () {
       })
     })
 
+    it('Should fail if email disabled and signup requires email verification', async function () {
+      // opposite scenario - success when enable enabled - covered via tests/api/users/user-verification.ts
+      const newUpdateParams = immutableAssign(updateParams, {
+        signup: {
+          enabled: true,
+          limit: 5,
+          requiresEmailVerification: true
+        }
+      })
+
+      await makePutBodyRequest({
+        url: server.url,
+        path,
+        fields: newUpdateParams,
+        token: server.accessToken,
+        statusCodeExpected: 400
+      })
+    })
+
     it('Should success with the correct parameters', async function () {
       await makePutBodyRequest({
         url: server.url,
@@ -195,11 +230,6 @@ describe('Test config API validators', function () {
   })
 
   after(async function () {
-    killallServers([ server ])
-
-    // Keep the logs if the test failed
-    if (this['ok']) {
-      await flushTests()
-    }
+    await cleanupTests([ server ])
   })
 })
diff --git a/server/tests/api/check-params/contact-form.ts b/server/tests/api/check-params/contact-form.ts
index c7e014b1f..dbdd3a8a6 100644
--- a/server/tests/api/check-params/contact-form.ts
+++ b/server/tests/api/check-params/contact-form.ts
@@ -7,18 +7,18 @@ import {
   immutableAssign,
   killallServers,
   reRunServer,
-  runServer,
+  flushAndRunServer,
   ServerInfo,
-  setAccessTokensToServers
-} from '../../../../shared/utils'
+  setAccessTokensToServers, cleanupTests
+} from '../../../../shared/extra-utils'
 import {
   checkBadCountPagination,
   checkBadSortPagination,
   checkBadStartPagination
-} from '../../../../shared/utils/requests/check-api-params'
-import { getAccount } from '../../../../shared/utils/users/accounts'
-import { sendContactForm } from '../../../../shared/utils/server/contact-form'
-import { MockSmtpServer } from '../../../../shared/utils/miscs/email'
+} from '../../../../shared/extra-utils/requests/check-api-params'
+import { getAccount } from '../../../../shared/extra-utils/users/accounts'
+import { sendContactForm } from '../../../../shared/extra-utils/server/contact-form'
+import { MockSmtpServer } from '../../../../shared/extra-utils/miscs/email'
 
 describe('Test contact form API validators', function () {
   let server: ServerInfo
@@ -28,17 +28,17 @@ describe('Test contact form API validators', function () {
     fromEmail: 'toto@example.com',
     body: 'Hello, how are you?'
   }
+  let emailPort: number
 
   // ---------------------------------------------------------------
 
   before(async function () {
     this.timeout(60000)
 
-    await flushTests()
-    await MockSmtpServer.Instance.collectEmails(emails)
+    emailPort = await MockSmtpServer.Instance.collectEmails(emails)
 
     // Email is disabled
-    server = await runServer(1)
+    server = await flushAndRunServer(1)
   })
 
   it('Should not accept a contact form if emails are disabled', async function () {
@@ -51,7 +51,7 @@ describe('Test contact form API validators', function () {
     killallServers([ server ])
 
     // Contact form is disabled
-    await reRunServer(server, { smtp: { hostname: 'localhost' }, contact_form: { enabled: false } })
+    await reRunServer(server, { smtp: { hostname: 'localhost', port: emailPort }, contact_form: { enabled: false } })
     await sendContactForm(immutableAssign(defaultBody, { url: server.url, expectedStatus: 409 }))
   })
 
@@ -61,7 +61,7 @@ describe('Test contact form API validators', function () {
     killallServers([ server ])
 
     // Email & contact form enabled
-    await reRunServer(server, { smtp: { hostname: 'localhost' } })
+    await reRunServer(server, { smtp: { hostname: 'localhost', port: emailPort } })
 
     await sendContactForm(immutableAssign(defaultBody, { url: server.url, expectedStatus: 400, fromEmail: 'badEmail' }))
     await sendContactForm(immutableAssign(defaultBody, { url: server.url, expectedStatus: 400, fromEmail: 'badEmail@' }))
@@ -86,11 +86,7 @@ describe('Test contact form API validators', function () {
 
   after(async function () {
     MockSmtpServer.Instance.kill()
-    killallServers([ server ])
 
-    // Keep the logs if the test failed
-    if (this['ok']) {
-      await flushTests()
-    }
+    await cleanupTests([ server ])
   })
 })
diff --git a/server/tests/api/check-params/debug.ts b/server/tests/api/check-params/debug.ts
new file mode 100644
index 000000000..8dad26723
--- /dev/null
+++ b/server/tests/api/check-params/debug.ts
@@ -0,0 +1,71 @@
+/* tslint:disable:no-unused-expression */
+
+import 'mocha'
+
+import {
+  createUser,
+  flushTests,
+  killallServers,
+  flushAndRunServer,
+  ServerInfo,
+  setAccessTokensToServers,
+  userLogin, cleanupTests
+} from '../../../../shared/extra-utils'
+import { makeGetRequest } from '../../../../shared/extra-utils/requests/requests'
+
+describe('Test debug API validators', function () {
+  const path = '/api/v1/server/debug'
+  let server: ServerInfo
+  let userAccessToken = ''
+
+  // ---------------------------------------------------------------
+
+  before(async function () {
+    this.timeout(120000)
+
+    server = await flushAndRunServer(1)
+
+    await setAccessTokensToServers([ server ])
+
+    const user = {
+      username: 'user1',
+      password: 'my super password'
+    }
+    await createUser({ url: server.url, accessToken: server.accessToken, username: user.username, password: user.password })
+    userAccessToken = await userLogin(server, user)
+  })
+
+  describe('When getting debug endpoint', function () {
+
+    it('Should fail with a non authenticated user', async function () {
+      await makeGetRequest({
+        url: server.url,
+        path,
+        statusCodeExpected: 401
+      })
+    })
+
+    it('Should fail with a non admin user', async function () {
+      await makeGetRequest({
+        url: server.url,
+        path,
+        token: userAccessToken,
+        statusCodeExpected: 403
+      })
+    })
+
+    it('Should succeed with the correct params', async function () {
+      await makeGetRequest({
+        url: server.url,
+        path,
+        token: server.accessToken,
+        query: { startDate: new Date().toISOString() },
+        statusCodeExpected: 200
+      })
+    })
+  })
+
+  after(async function () {
+    await cleanupTests([ server ])
+  })
+})
diff --git a/server/tests/api/check-params/follows.ts b/server/tests/api/check-params/follows.ts
index 2ad1575a3..2eb54cb0a 100644
--- a/server/tests/api/check-params/follows.ts
+++ b/server/tests/api/check-params/follows.ts
@@ -3,14 +3,20 @@
 import 'mocha'
 
 import {
-  createUser, flushTests, killallServers, makeDeleteRequest, makePostBodyRequest, runServer, ServerInfo, setAccessTokensToServers,
+  cleanupTests,
+  createUser,
+  flushAndRunServer,
+  makeDeleteRequest,
+  makePostBodyRequest,
+  ServerInfo,
+  setAccessTokensToServers,
   userLogin
-} from '../../../../shared/utils'
+} from '../../../../shared/extra-utils'
 import {
   checkBadCountPagination,
   checkBadSortPagination,
   checkBadStartPagination
-} from '../../../../shared/utils/requests/check-api-params'
+} from '../../../../shared/extra-utils/requests/check-api-params'
 
 describe('Test server follows API validators', function () {
   let server: ServerInfo
@@ -20,8 +26,7 @@ describe('Test server follows API validators', function () {
   before(async function () {
     this.timeout(30000)
 
-    await flushTests()
-    server = await runServer(1)
+    server = await flushAndRunServer(1)
 
     await setAccessTokensToServers([ server ])
   })
@@ -35,7 +40,7 @@ describe('Test server follows API validators', function () {
         password: 'password'
       }
 
-      await createUser(server.url, server.accessToken, user.username, user.password)
+      await createUser({ url: server.url, accessToken: server.accessToken, username: user.username, password: user.password })
       userAccessToken = await userLogin(server, user)
     })
 
@@ -144,6 +149,126 @@ describe('Test server follows API validators', function () {
       })
     })
 
+    describe('When removing a follower', function () {
+      const path = '/api/v1/server/followers'
+
+      it('Should fail with an invalid token', async function () {
+        await makeDeleteRequest({
+          url: server.url,
+          path: path + '/toto@localhost:9002',
+          token: 'fake_token',
+          statusCodeExpected: 401
+        })
+      })
+
+      it('Should fail if the user is not an administrator', async function () {
+        await makeDeleteRequest({
+          url: server.url,
+          path: path + '/toto@localhost:9002',
+          token: userAccessToken,
+          statusCodeExpected: 403
+        })
+      })
+
+      it('Should fail with an invalid follower', async function () {
+        await makeDeleteRequest({
+          url: server.url,
+          path: path + '/toto',
+          token: server.accessToken,
+          statusCodeExpected: 400
+        })
+      })
+
+      it('Should fail with an unknown follower', async function () {
+        await makeDeleteRequest({
+          url: server.url,
+          path: path + '/toto@localhost:9003',
+          token: server.accessToken,
+          statusCodeExpected: 404
+        })
+      })
+    })
+
+    describe('When accepting a follower', function () {
+      const path = '/api/v1/server/followers'
+
+      it('Should fail with an invalid token', async function () {
+        await makePostBodyRequest({
+          url: server.url,
+          path: path + '/toto@localhost:9002/accept',
+          token: 'fake_token',
+          statusCodeExpected: 401
+        })
+      })
+
+      it('Should fail if the user is not an administrator', async function () {
+        await makePostBodyRequest({
+          url: server.url,
+          path: path + '/toto@localhost:9002/accept',
+          token: userAccessToken,
+          statusCodeExpected: 403
+        })
+      })
+
+      it('Should fail with an invalid follower', async function () {
+        await makePostBodyRequest({
+          url: server.url,
+          path: path + '/toto/accept',
+          token: server.accessToken,
+          statusCodeExpected: 400
+        })
+      })
+
+      it('Should fail with an unknown follower', async function () {
+        await makePostBodyRequest({
+          url: server.url,
+          path: path + '/toto@localhost:9003/accept',
+          token: server.accessToken,
+          statusCodeExpected: 404
+        })
+      })
+    })
+
+    describe('When rejecting a follower', function () {
+      const path = '/api/v1/server/followers'
+
+      it('Should fail with an invalid token', async function () {
+        await makePostBodyRequest({
+          url: server.url,
+          path: path + '/toto@localhost:9002/reject',
+          token: 'fake_token',
+          statusCodeExpected: 401
+        })
+      })
+
+      it('Should fail if the user is not an administrator', async function () {
+        await makePostBodyRequest({
+          url: server.url,
+          path: path + '/toto@localhost:9002/reject',
+          token: userAccessToken,
+          statusCodeExpected: 403
+        })
+      })
+
+      it('Should fail with an invalid follower', async function () {
+        await makePostBodyRequest({
+          url: server.url,
+          path: path + '/toto/reject',
+          token: server.accessToken,
+          statusCodeExpected: 400
+        })
+      })
+
+      it('Should fail with an unknown follower', async function () {
+        await makePostBodyRequest({
+          url: server.url,
+          path: path + '/toto@localhost:9003/reject',
+          token: server.accessToken,
+          statusCodeExpected: 404
+        })
+      })
+    })
+
     describe('When removing following', function () {
       const path = '/api/v1/server/following'
 
@@ -177,11 +302,6 @@ describe('Test server follows API validators', function () {
   })
 
   after(async function () {
-    killallServers([ server ])
-
-    // Keep the logs if the test failed
-    if (this['ok']) {
-      await flushTests()
-    }
+    await cleanupTests([ server ])
   })
 })
diff --git a/server/tests/api/check-params/index.ts b/server/tests/api/check-params/index.ts
index 77c17036a..844fa31c5 100644
--- a/server/tests/api/check-params/index.ts
+++ b/server/tests/api/check-params/index.ts
@@ -2,8 +2,10 @@ import './accounts'
 import './blocklist'
 import './config'
 import './contact-form'
+import './debug'
 import './follows'
 import './jobs'
+import './logs'
 import './redundancy'
 import './search'
 import './services'
@@ -16,6 +18,7 @@ import './video-captions'
 import './video-channels'
 import './video-comments'
 import './video-imports'
+import './video-playlists'
 import './videos'
 import './videos-filter'
 import './videos-history'
diff --git a/server/tests/api/check-params/jobs.ts b/server/tests/api/check-params/jobs.ts
index 89760ff98..c70139514 100644
--- a/server/tests/api/check-params/jobs.ts
+++ b/server/tests/api/check-params/jobs.ts
@@ -6,17 +6,18 @@ import {
   createUser,
   flushTests,
   killallServers,
-  runServer,
+  flushAndRunServer,
   ServerInfo,
   setAccessTokensToServers,
-  userLogin
-} from '../../../../shared/utils'
+  userLogin,
+  cleanupTests
+} from '../../../../shared/extra-utils'
 import {
   checkBadCountPagination,
   checkBadSortPagination,
   checkBadStartPagination
-} from '../../../../shared/utils/requests/check-api-params'
-import { makeGetRequest } from '../../../../shared/utils/requests/requests'
+} from '../../../../shared/extra-utils/requests/check-api-params'
+import { makeGetRequest } from '../../../../shared/extra-utils/requests/requests'
 
 describe('Test jobs API validators', function () {
   const path = '/api/v1/jobs/failed'
@@ -28,9 +29,7 @@ describe('Test jobs API validators', function () {
   before(async function () {
     this.timeout(120000)
 
-    await flushTests()
-
-    server = await runServer(1)
+    server = await flushAndRunServer(1)
 
     await setAccessTokensToServers([ server ])
 
@@ -38,7 +37,7 @@ describe('Test jobs API validators', function () {
       username: 'user1',
       password: 'my super password'
     }
-    await createUser(server.url, server.accessToken, user.username, user.password)
+    await createUser({ url: server.url, accessToken: server.accessToken, username: user.username, password: user.password })
     userAccessToken = await userLogin(server, user)
   })
 
@@ -83,11 +82,6 @@ describe('Test jobs API validators', function () {
   })
 
   after(async function () {
-    killallServers([ server ])
-
-    // Keep the logs if the test failed
-    if (this['ok']) {
-      await flushTests()
-    }
+    await cleanupTests([ server ])
   })
 })
diff --git a/server/tests/api/check-params/logs.ts b/server/tests/api/check-params/logs.ts
new file mode 100644
index 000000000..f9d96bcc0
--- /dev/null
+++ b/server/tests/api/check-params/logs.ts
@@ -0,0 +1,111 @@
+/* tslint:disable:no-unused-expression */
+
+import 'mocha'
+
+import {
+  createUser,
+  flushTests,
+  killallServers,
+  flushAndRunServer,
+  ServerInfo,
+  setAccessTokensToServers,
+  userLogin,
+  cleanupTests
+} from '../../../../shared/extra-utils'
+import { makeGetRequest } from '../../../../shared/extra-utils/requests/requests'
+
+describe('Test logs API validators', function () {
+  const path = '/api/v1/server/logs'
+  let server: ServerInfo
+  let userAccessToken = ''
+
+  // ---------------------------------------------------------------
+
+  before(async function () {
+    this.timeout(120000)
+
+    server = await flushAndRunServer(1)
+
+    await setAccessTokensToServers([ server ])
+
+    const user = {
+      username: 'user1',
+      password: 'my super password'
+    }
+    await createUser({ url: server.url, accessToken: server.accessToken, username: user.username, password: user.password })
+    userAccessToken = await userLogin(server, user)
+  })
+
+  describe('When getting logs', function () {
+
+    it('Should fail with a non authenticated user', async function () {
+      await makeGetRequest({
+        url: server.url,
+        path,
+        statusCodeExpected: 401
+      })
+    })
+
+    it('Should fail with a non admin user', async function () {
+      await makeGetRequest({
+        url: server.url,
+        path,
+        token: userAccessToken,
+        statusCodeExpected: 403
+      })
+    })
+
+    it('Should fail with a missing startDate query', async function () {
+      await makeGetRequest({
+        url: server.url,
+        path,
+        token: server.accessToken,
+        statusCodeExpected: 400
+      })
+    })
+
+    it('Should fail with a bad startDate query', async function () {
+      await makeGetRequest({
+        url: server.url,
+        path,
+        token: server.accessToken,
+        query: { startDate: 'toto' },
+        statusCodeExpected: 400
+      })
+    })
+
+    it('Should fail with a bad endDate query', async function () {
+      await makeGetRequest({
+        url: server.url,
+        path,
+        token: server.accessToken,
+        query: { startDate: new Date().toISOString(), endDate: 'toto' },
+        statusCodeExpected: 400
+      })
+    })
+
+    it('Should fail with a bad level parameter', async function () {
+      await makeGetRequest({
+        url: server.url,
+        path,
+        token: server.accessToken,
+        query: { startDate: new Date().toISOString(), level: 'toto' },
+        statusCodeExpected: 400
+      })
+    })
+
+    it('Should succeed with the correct params', async function () {
+      await makeGetRequest({
+        url: server.url,
+        path,
+        token: server.accessToken,
+        query: { startDate: new Date().toISOString() },
+        statusCodeExpected: 200
+      })
+    })
+  })
+
+  after(async function () {
+    await cleanupTests([ server ])
+  })
+})
diff --git a/server/tests/api/check-params/redundancy.ts b/server/tests/api/check-params/redundancy.ts
index ff4726ceb..6471da840 100644
--- a/server/tests/api/check-params/redundancy.ts
+++ b/server/tests/api/check-params/redundancy.ts
@@ -3,6 +3,7 @@
 import 'mocha'
 
 import {
+  cleanupTests,
   createUser,
   doubleFollow,
   flushAndRunMultipleServers,
@@ -12,7 +13,7 @@ import {
   ServerInfo,
   setAccessTokensToServers,
   userLogin
-} from '../../../../shared/utils'
+} from '../../../../shared/extra-utils'
 
 describe('Test server redundancy API validators', function () {
   let servers: ServerInfo[]
@@ -23,7 +24,6 @@ describe('Test server redundancy API validators', function () {
   before(async function () {
     this.timeout(30000)
 
-    await flushTests()
     servers = await flushAndRunMultipleServers(2)
 
     await setAccessTokensToServers(servers)
@@ -34,7 +34,7 @@ describe('Test server redundancy API validators', function () {
       password: 'password'
     }
 
-    await createUser(servers[0].url, servers[0].accessToken, user.username, user.password)
+    await createUser({ url: servers[ 0 ].url, accessToken: servers[ 0 ].accessToken, username: user.username, password: user.password })
     userAccessToken = await userLogin(servers[0], user)
   })
 
@@ -44,7 +44,7 @@ describe('Test server redundancy API validators', function () {
     it('Should fail with an invalid token', async function () {
       await makePutBodyRequest({
         url: servers[0].url,
-        path: path + '/localhost:9002',
+        path: path + '/localhost:' + servers[1].port,
         fields: { redundancyAllowed: true },
         token: 'fake_token',
         statusCodeExpected: 401
@@ -54,7 +54,7 @@ describe('Test server redundancy API validators', function () {
     it('Should fail if the user is not an administrator', async function () {
       await makePutBodyRequest({
         url: servers[0].url,
-        path: path + '/localhost:9002',
+        path: path + '/localhost:' + servers[1].port,
         fields: { redundancyAllowed: true },
         token: userAccessToken,
         statusCodeExpected: 403
@@ -74,7 +74,7 @@ describe('Test server redundancy API validators', function () {
     it('Should fail without de redundancyAllowed param', async function () {
       await makePutBodyRequest({
         url: servers[0].url,
-        path: path + '/localhost:9002',
+        path: path + '/localhost:' + servers[1].port,
         fields: { blabla: true },
         token: servers[0].accessToken,
         statusCodeExpected: 400
@@ -84,7 +84,7 @@ describe('Test server redundancy API validators', function () {
     it('Should succeed with the correct parameters', async function () {
       await makePutBodyRequest({
         url: servers[0].url,
-        path: path + '/localhost:9002',
+        path: path + '/localhost:' + servers[1].port,
         fields: { redundancyAllowed: true },
         token: servers[0].accessToken,
         statusCodeExpected: 204
@@ -93,11 +93,6 @@ describe('Test server redundancy API validators', function () {
   })
 
   after(async function () {
-    killallServers(servers)
-
-    // Keep the logs if the test failed
-    if (this['ok']) {
-      await flushTests()
-    }
+    await cleanupTests(servers)
   })
 })
diff --git a/server/tests/api/check-params/search.ts b/server/tests/api/check-params/search.ts
index aa81965f3..8ad9d98bf 100644
--- a/server/tests/api/check-params/search.ts
+++ b/server/tests/api/check-params/search.ts
@@ -2,12 +2,12 @@
 
 import 'mocha'
 
-import { flushTests, immutableAssign, killallServers, makeGetRequest, runServer, ServerInfo } from '../../../../shared/utils'
+import { cleanupTests, flushAndRunServer, immutableAssign, makeGetRequest, ServerInfo } from '../../../../shared/extra-utils'
 import {
   checkBadCountPagination,
   checkBadSortPagination,
   checkBadStartPagination
-} from '../../../../shared/utils/requests/check-api-params'
+} from '../../../../shared/extra-utils/requests/check-api-params'
 
 describe('Test videos API validator', function () {
   let server: ServerInfo
@@ -17,9 +17,7 @@ describe('Test videos API validator', function () {
   before(async function () {
     this.timeout(30000)
 
-    await flushTests()
-
-    server = await runServer(1)
+    server = await flushAndRunServer(1)
   })
 
   describe('When searching videos', function () {
@@ -113,6 +111,12 @@ describe('Test videos API validator', function () {
 
       const customQuery2 = immutableAssign(query, { endDate: 'hello' })
       await makeGetRequest({ url: server.url, path, query: customQuery2, statusCodeExpected: 400 })
+
+      const customQuery3 = immutableAssign(query, { originallyPublishedStartDate: 'hello' })
+      await makeGetRequest({ url: server.url, path, query: customQuery3, statusCodeExpected: 400 })
+
+      const customQuery4 = immutableAssign(query, { originallyPublishedEndDate: 'hello' })
+      await makeGetRequest({ url: server.url, path, query: customQuery4, statusCodeExpected: 400 })
     })
   })
 
@@ -141,11 +145,6 @@ describe('Test videos API validator', function () {
   })
 
   after(async function () {
-    killallServers([ server ])
-
-    // Keep the logs if the test failed
-    if (this['ok']) {
-      await flushTests()
-    }
+    await cleanupTests([ server ])
   })
 })
diff --git a/server/tests/api/check-params/services.ts b/server/tests/api/check-params/services.ts
index 28591af9d..d15753aed 100644
--- a/server/tests/api/check-params/services.ts
+++ b/server/tests/api/check-params/services.ts
@@ -3,14 +3,13 @@
 import 'mocha'
 
 import {
-  flushTests,
-  killallServers,
+  cleanupTests,
+  flushAndRunServer,
   makeGetRequest,
-  runServer,
   ServerInfo,
   setAccessTokensToServers,
   uploadVideo
-} from '../../../../shared/utils'
+} from '../../../../shared/extra-utils'
 
 describe('Test services API validators', function () {
   let server: ServerInfo
@@ -20,9 +19,7 @@ describe('Test services API validators', function () {
   before(async function () {
     this.timeout(60000)
 
-    await flushTests()
-
-    server = await runServer(1)
+    server = await flushAndRunServer(1)
     await setAccessTokensToServers([ server ])
 
     const res = await uploadVideo(server.url, server.accessToken, { name: 'my super name' })
@@ -42,47 +39,47 @@ describe('Test services API validators', function () {
     })
 
     it('Should fail with an invalid video id', async function () {
-      const embedUrl = 'http://localhost:9001/videos/watch/blabla'
+      const embedUrl = `http://localhost:${server.port}/videos/watch/blabla`
       await checkParamEmbed(server, embedUrl)
     })
 
     it('Should fail with an unknown video', async function () {
-      const embedUrl = 'http://localhost:9001/videos/watch/88fc0165-d1f0-4a35-a51a-3b47f668689c'
+      const embedUrl = `http://localhost:${server.port}/videos/watch/88fc0165-d1f0-4a35-a51a-3b47f668689c`
       await checkParamEmbed(server, embedUrl, 404)
     })
 
     it('Should fail with an invalid path', async function () {
-      const embedUrl = 'http://localhost:9001/videos/watchs/' + server.video.uuid
+      const embedUrl = `http://localhost:${server.port}/videos/watchs/${server.video.uuid}`
 
       await checkParamEmbed(server, embedUrl)
     })
 
     it('Should fail with an invalid max height', async function () {
-      const embedUrl = 'http://localhost:9001/videos/watch/' + server.video.uuid
+      const embedUrl = `http://localhost:${server.port}/videos/watch/${server.video.uuid}`
 
       await checkParamEmbed(server, embedUrl, 400, { maxheight: 'hello' })
     })
 
     it('Should fail with an invalid max width', async function () {
-      const embedUrl = 'http://localhost:9001/videos/watch/' + server.video.uuid
+      const embedUrl = `http://localhost:${server.port}/videos/watch/${server.video.uuid}`
 
       await checkParamEmbed(server, embedUrl, 400, { maxwidth: 'hello' })
     })
 
     it('Should fail with an invalid format', async function () {
-      const embedUrl = 'http://localhost:9001/videos/watch/' + server.video.uuid
+      const embedUrl = `http://localhost:${server.port}/videos/watch/${server.video.uuid}`
 
       await checkParamEmbed(server, embedUrl, 400, { format: 'blabla' })
     })
 
     it('Should fail with a non supported format', async function () {
-      const embedUrl = 'http://localhost:9001/videos/watch/' + server.video.uuid
+      const embedUrl = `http://localhost:${server.port}/videos/watch/${server.video.uuid}`
 
       await checkParamEmbed(server, embedUrl, 501, { format: 'xml' })
     })
 
     it('Should succeed with the correct params', async function () {
-      const embedUrl = 'http://localhost:9001/videos/watch/' + server.video.uuid
+      const embedUrl = `http://localhost:${server.port}/videos/watch/${server.video.uuid}`
       const query = {
         format: 'json',
         maxheight: 400,
@@ -94,12 +91,7 @@ describe('Test services API validators', function () {
   })
 
   after(async function () {
-    killallServers([ server ])
-
-    // Keep the logs if the test failed
-    if (this['ok']) {
-      await flushTests()
-    }
+    await cleanupTests([ server ])
   })
 })
 
diff --git a/server/tests/api/check-params/user-notifications.ts b/server/tests/api/check-params/user-notifications.ts
index 714f481e9..14ee20d45 100644
--- a/server/tests/api/check-params/user-notifications.ts
+++ b/server/tests/api/check-params/user-notifications.ts
@@ -4,22 +4,21 @@ import 'mocha'
 import * as io from 'socket.io-client'
 
 import {
-  flushTests,
+  cleanupTests,
+  flushAndRunServer,
   immutableAssign,
-  killallServers,
   makeGetRequest,
   makePostBodyRequest,
   makePutBodyRequest,
-  runServer,
   ServerInfo,
   setAccessTokensToServers,
   wait
-} from '../../../../shared/utils'
+} from '../../../../shared/extra-utils'
 import {
   checkBadCountPagination,
   checkBadSortPagination,
   checkBadStartPagination
-} from '../../../../shared/utils/requests/check-api-params'
+} from '../../../../shared/extra-utils/requests/check-api-params'
 import { UserNotificationSetting, UserNotificationSettingValue } from '../../../../shared/models/users'
 
 describe('Test user notifications API validators', function () {
@@ -30,9 +29,7 @@ describe('Test user notifications API validators', function () {
   before(async function () {
     this.timeout(30000)
 
-    await flushTests()
-
-    server = await runServer(1)
+    server = await flushAndRunServer(1)
 
     await setAccessTokensToServers([ server ])
   })
@@ -168,12 +165,14 @@ describe('Test user notifications API validators', function () {
       newVideoFromSubscription: UserNotificationSettingValue.WEB,
       newCommentOnMyVideo: UserNotificationSettingValue.WEB,
       videoAbuseAsModerator: UserNotificationSettingValue.WEB,
+      videoAutoBlacklistAsModerator: UserNotificationSettingValue.WEB,
       blacklistOnMyVideo: UserNotificationSettingValue.WEB,
       myVideoImportFinished: UserNotificationSettingValue.WEB,
       myVideoPublished: UserNotificationSettingValue.WEB,
       commentMention: UserNotificationSettingValue.WEB,
       newFollow: UserNotificationSettingValue.WEB,
-      newUserRegistration: UserNotificationSettingValue.WEB
+      newUserRegistration: UserNotificationSettingValue.WEB,
+      newInstanceFollower: UserNotificationSettingValue.WEB
     }
 
     it('Should fail with missing fields', async function () {
@@ -234,7 +233,7 @@ describe('Test user notifications API validators', function () {
 
   describe('When connecting to my notification socket', function () {
     it('Should fail with no token', function (next) {
-      const socket = io('http://localhost:9001/user-notifications', { reconnection: false })
+      const socket = io(`http://localhost:${server.port}/user-notifications`, { reconnection: false })
 
       socket.on('error', () => {
         socket.removeListener('error', this)
@@ -249,7 +248,7 @@ describe('Test user notifications API validators', function () {
     })
 
     it('Should fail with an invalid token', function (next) {
-      const socket = io('http://localhost:9001/user-notifications', {
+      const socket = io(`http://localhost:${server.port}/user-notifications`, {
         query: { accessToken: 'bad_access_token' },
         reconnection: false
       })
@@ -267,7 +266,7 @@ describe('Test user notifications API validators', function () {
     })
 
     it('Should success with the correct token', function (next) {
-      const socket = io('http://localhost:9001/user-notifications', {
+      const socket = io(`http://localhost:${server.port}/user-notifications`, {
         query: { accessToken: server.accessToken },
         reconnection: false
       })
@@ -287,11 +286,6 @@ describe('Test user notifications API validators', function () {
   })
 
   after(async function () {
-    killallServers([ server ])
-
-    // Keep the logs if the test failed
-    if (this['ok']) {
-      await flushTests()
-    }
+    await cleanupTests([ server ])
   })
 })
diff --git a/server/tests/api/check-params/user-subscriptions.ts b/server/tests/api/check-params/user-subscriptions.ts
index 8a9ced7c1..fa36c4078 100644
--- a/server/tests/api/check-params/user-subscriptions.ts
+++ b/server/tests/api/check-params/user-subscriptions.ts
@@ -3,24 +3,23 @@
 import 'mocha'
 
 import {
+  cleanupTests,
   createUser,
-  flushTests,
-  killallServers,
+  flushAndRunServer,
   makeDeleteRequest,
   makeGetRequest,
   makePostBodyRequest,
-  runServer,
   ServerInfo,
   setAccessTokensToServers,
   userLogin
-} from '../../../../shared/utils'
+} from '../../../../shared/extra-utils'
 
 import {
   checkBadCountPagination,
   checkBadSortPagination,
   checkBadStartPagination
-} from '../../../../shared/utils/requests/check-api-params'
-import { waitJobs } from '../../../../shared/utils/server/jobs'
+} from '../../../../shared/extra-utils/requests/check-api-params'
+import { waitJobs } from '../../../../shared/extra-utils/server/jobs'
 
 describe('Test user subscriptions API validators', function () {
   const path = '/api/v1/users/me/subscriptions'
@@ -32,9 +31,7 @@ describe('Test user subscriptions API validators', function () {
   before(async function () {
     this.timeout(30000)
 
-    await flushTests()
-
-    server = await runServer(1)
+    server = await flushAndRunServer(1)
 
     await setAccessTokensToServers([ server ])
 
@@ -42,7 +39,7 @@ describe('Test user subscriptions API validators', function () {
       username: 'user1',
       password: 'my super password'
     }
-    await createUser(server.url, server.accessToken, user.username, user.password)
+    await createUser({ url: server.url, accessToken: server.accessToken, username: user.username, password: user.password })
     userAccessToken = await userLogin(server, user)
   })
 
@@ -115,7 +112,7 @@ describe('Test user subscriptions API validators', function () {
       await makePostBodyRequest({
         url: server.url,
         path,
-        fields: { uri: 'user1_channel@localhost:9001' },
+        fields: { uri: 'user1_channel@localhost:' + server.port },
         statusCodeExpected: 401
       })
     })
@@ -153,7 +150,7 @@ describe('Test user subscriptions API validators', function () {
         url: server.url,
         path,
         token: server.accessToken,
-        fields: { uri: 'user1_channel@localhost:9001' },
+        fields: { uri: 'user1_channel@localhost:' + server.port },
         statusCodeExpected: 204
       })
 
@@ -165,7 +162,7 @@ describe('Test user subscriptions API validators', function () {
     it('Should fail with a non authenticated user', async function () {
       await makeGetRequest({
         url: server.url,
-        path: path + '/user1_channel@localhost:9001',
+        path: path + '/user1_channel@localhost:' + server.port,
         statusCodeExpected: 401
       })
     })
@@ -196,7 +193,7 @@ describe('Test user subscriptions API validators', function () {
     it('Should fail with an unknown subscription', async function () {
       await makeGetRequest({
         url: server.url,
-        path: path + '/root1@localhost:9001',
+        path: path + '/root1@localhost:' + server.port,
         token: server.accessToken,
         statusCodeExpected: 404
       })
@@ -205,14 +202,14 @@ describe('Test user subscriptions API validators', function () {
     it('Should succeed with the correct parameters', async function () {
       await makeGetRequest({
         url: server.url,
-        path: path + '/user1_channel@localhost:9001',
+        path: path + '/user1_channel@localhost:' + server.port,
         token: server.accessToken,
         statusCodeExpected: 200
       })
     })
   })
 
-  describe('When checking if subscriptions exist', async function () {
+  describe('When checking if subscriptions exist', function () {
     const existPath = path + '/exist'
 
     it('Should fail with a non authenticated user', async function () {
@@ -245,7 +242,7 @@ describe('Test user subscriptions API validators', function () {
       await makeGetRequest({
         url: server.url,
         path: existPath,
-        query: { 'uris[]': 'coucou@localhost:9001' },
+        query: { 'uris[]': 'coucou@localhost:' + server.port },
         token: server.accessToken,
         statusCodeExpected: 200
       })
@@ -256,7 +253,7 @@ describe('Test user subscriptions API validators', function () {
     it('Should fail with a non authenticated user', async function () {
       await makeDeleteRequest({
         url: server.url,
-        path: path + '/user1_channel@localhost:9001',
+        path: path + '/user1_channel@localhost:' + server.port,
         statusCodeExpected: 401
       })
     })
@@ -287,7 +284,7 @@ describe('Test user subscriptions API validators', function () {
     it('Should fail with an unknown subscription', async function () {
       await makeDeleteRequest({
         url: server.url,
-        path: path + '/root1@localhost:9001',
+        path: path + '/root1@localhost:' + server.port,
         token: server.accessToken,
         statusCodeExpected: 404
       })
@@ -296,7 +293,7 @@ describe('Test user subscriptions API validators', function () {
     it('Should succeed with the correct parameters', async function () {
       await makeDeleteRequest({
         url: server.url,
-        path: path + '/user1_channel@localhost:9001',
+        path: path + '/user1_channel@localhost:' + server.port,
         token: server.accessToken,
         statusCodeExpected: 204
       })
@@ -304,11 +301,6 @@ describe('Test user subscriptions API validators', function () {
   })
 
   after(async function () {
-    killallServers([ server ])
-
-    // Keep the logs if the test failed
-    if (this['ok']) {
-      await flushTests()
-    }
+    await cleanupTests([ server ])
   })
 })
diff --git a/server/tests/api/check-params/users.ts b/server/tests/api/check-params/users.ts
index a3e8e2e9c..5935104a5 100644
--- a/server/tests/api/check-params/users.ts
+++ b/server/tests/api/check-params/users.ts
@@ -6,19 +6,38 @@ import { join } from 'path'
 import { UserRole, VideoImport, VideoImportState } from '../../../../shared'
 
 import {
-  createUser, flushTests, getMyUserInformation, getMyUserVideoRating, getUsersList, immutableAssign, killallServers, makeGetRequest,
-  makePostBodyRequest, makeUploadRequest, makePutBodyRequest, registerUser, removeUser, runServer, ServerInfo, setAccessTokensToServers,
-  updateUser, uploadVideo, userLogin, deleteMe, unblockUser, blockUser
-} from '../../../../shared/utils'
+  blockUser,
+  cleanupTests,
+  createUser,
+  deleteMe,
+  flushAndRunServer,
+  getMyUserInformation,
+  getMyUserVideoRating,
+  getUsersList,
+  immutableAssign,
+  makeGetRequest,
+  makePostBodyRequest,
+  makePutBodyRequest,
+  makeUploadRequest,
+  registerUser,
+  removeUser,
+  ServerInfo,
+  setAccessTokensToServers,
+  unblockUser,
+  updateUser,
+  uploadVideo,
+  userLogin
+} from '../../../../shared/extra-utils'
 import {
   checkBadCountPagination,
   checkBadSortPagination,
   checkBadStartPagination
-} from '../../../../shared/utils/requests/check-api-params'
-import { getMagnetURI, getMyVideoImports, getYoutubeVideoUrl, importVideo } from '../../../../shared/utils/videos/video-imports'
+} from '../../../../shared/extra-utils/requests/check-api-params'
+import { getMagnetURI, getMyVideoImports, getYoutubeVideoUrl, importVideo } from '../../../../shared/extra-utils/videos/video-imports'
 import { VideoPrivacy } from '../../../../shared/models/videos'
-import { waitJobs } from '../../../../shared/utils/server/jobs'
+import { waitJobs } from '../../../../shared/extra-utils/server/jobs'
 import { expect } from 'chai'
+import { UserAdminFlag } from '../../../../shared/models/users/user-flag.model'
 
 describe('Test users API validators', function () {
   const path = '/api/v1/users/'
@@ -39,15 +58,19 @@ describe('Test users API validators', function () {
   before(async function () {
     this.timeout(30000)
 
-    await flushTests()
-
-    server = await runServer(1)
-    serverWithRegistrationDisabled = await runServer(2)
+    server = await flushAndRunServer(1)
+    serverWithRegistrationDisabled = await flushAndRunServer(2)
 
     await setAccessTokensToServers([ server ])
 
     const videoQuota = 42000000
-    await createUser(server.url, server.accessToken, user.username, user.password, videoQuota)
+    await createUser({
+      url: server.url,
+      accessToken: server.accessToken,
+      username: user.username,
+      password: user.password,
+      videoQuota: videoQuota
+    })
     userAccessToken = await userLogin(server, user)
 
     {
@@ -99,7 +122,8 @@ describe('Test users API validators', function () {
       password: 'my super password',
       videoQuota: -1,
       videoQuotaDaily: -1,
-      role: UserRole.USER
+      role: UserRole.USER,
+      adminFlags: UserAdminFlag.BY_PASS_VIDEO_AUTO_BLACKLIST
     }
 
     it('Should fail with a too small username', async function () {
@@ -150,6 +174,12 @@ describe('Test users API validators', function () {
       await makePostBodyRequest({ url: server.url, path, token: server.accessToken, fields })
     })
 
+    it('Should fail with invalid admin flags', async function () {
+      const fields = immutableAssign(baseCorrectParams, { adminFlags: 'toto' })
+
+      await makePostBodyRequest({ url: server.url, path, token: server.accessToken, fields })
+    })
+
     it('Should fail with an non authenticated user', async function () {
       await makePostBodyRequest({
         url: server.url,
@@ -464,6 +494,24 @@ describe('Test users API validators', function () {
       await makePutBodyRequest({ url: server.url, path: path + userId, token: server.accessToken, fields })
     })
 
+    it('Should fail with a too small password', async function () {
+      const fields = {
+        currentPassword: 'my super password',
+        password: 'bla'
+      }
+
+      await makePutBodyRequest({ url: server.url, path: path + userId, token: server.accessToken, fields })
+    })
+
+    it('Should fail with a too long password', async function () {
+      const fields = {
+        currentPassword: 'my super password',
+        password: 'super'.repeat(61)
+      }
+
+      await makePutBodyRequest({ url: server.url, path: path + userId, token: server.accessToken, fields })
+    })
+
     it('Should fail with an non authenticated user', async function () {
       const fields = {
         videoQuota: 42
@@ -480,6 +528,12 @@ describe('Test users API validators', function () {
       await makePutBodyRequest({ url: server.url, path: path + rootId, token: server.accessToken, fields })
     })
 
+    it('Should fail with invalid admin flags', async function () {
+      const fields = { adminFlags: 'toto' }
+
+      await makePostBodyRequest({ url: server.url, path, token: server.accessToken, fields })
+    })
+
     it('Should succeed with the correct params', async function () {
       const fields = {
         email: 'email@example.com',
@@ -520,6 +574,38 @@ describe('Test users API validators', function () {
     })
   })
 
+  describe('When retrieving my global ratings', function () {
+    const path = '/api/v1/accounts/user1/ratings'
+
+    it('Should fail with a bad start pagination', async function () {
+      await checkBadStartPagination(server.url, path, userAccessToken)
+    })
+
+    it('Should fail with a bad count pagination', async function () {
+      await checkBadCountPagination(server.url, path, userAccessToken)
+    })
+
+    it('Should fail with an incorrect sort', async function () {
+      await checkBadSortPagination(server.url, path, userAccessToken)
+    })
+
+    it('Should fail with a unauthenticated user', async function () {
+      await makeGetRequest({ url: server.url, path, statusCodeExpected: 401 })
+    })
+
+    it('Should fail with a another user', async function () {
+      await makeGetRequest({ url: server.url, path, token: server.accessToken, statusCodeExpected: 403 })
+    })
+
+    it('Should fail with a bad type', async function () {
+      await makeGetRequest({ url: server.url, path, token: userAccessToken, query: { rating: 'toto ' }, statusCodeExpected: 400 })
+    })
+
+    it('Should succeed with the correct params', async function () {
+      await makeGetRequest({ url: server.url, path, token: userAccessToken, statusCodeExpected: 200 })
+    })
+  })
+
   describe('When blocking/unblocking/removing user', function () {
     it('Should fail with an incorrect id', async function () {
       await removeUser(server.url, 'blabla', server.accessToken, 400)
@@ -627,7 +713,7 @@ describe('Test users API validators', function () {
     })
 
     it('Should fail if we register a user with the same email', async function () {
-      const fields = immutableAssign(baseCorrectParams, { email: 'admin1@example.com' })
+      const fields = immutableAssign(baseCorrectParams, { email: 'admin' + server.internalServerNumber + '@example.com' })
 
       await makePostBodyRequest({
         url: server.url,
@@ -812,11 +898,6 @@ describe('Test users API validators', function () {
   })
 
   after(async function () {
-    killallServers([ server, serverWithRegistrationDisabled ])
-
-    // Keep the logs if the test failed
-    if (this['ok']) {
-      await flushTests()
-    }
+    await cleanupTests([ server, serverWithRegistrationDisabled ])
   })
 })
diff --git a/server/tests/api/check-params/video-abuses.ts b/server/tests/api/check-params/video-abuses.ts
index 3b8f5f14d..bf29f8d4d 100644
--- a/server/tests/api/check-params/video-abuses.ts
+++ b/server/tests/api/check-params/video-abuses.ts
@@ -3,24 +3,23 @@
 import 'mocha'
 
 import {
+  cleanupTests,
   createUser,
   deleteVideoAbuse,
-  flushTests,
-  killallServers,
+  flushAndRunServer,
   makeGetRequest,
   makePostBodyRequest,
-  runServer,
   ServerInfo,
   setAccessTokensToServers,
   updateVideoAbuse,
   uploadVideo,
   userLogin
-} from '../../../../shared/utils'
+} from '../../../../shared/extra-utils'
 import {
   checkBadCountPagination,
   checkBadSortPagination,
   checkBadStartPagination
-} from '../../../../shared/utils/requests/check-api-params'
+} from '../../../../shared/extra-utils/requests/check-api-params'
 import { VideoAbuseState } from '../../../../shared/models/videos'
 
 describe('Test video abuses API validators', function () {
@@ -33,15 +32,13 @@ describe('Test video abuses API validators', function () {
   before(async function () {
     this.timeout(30000)
 
-    await flushTests()
-
-    server = await runServer(1)
+    server = await flushAndRunServer(1)
 
     await setAccessTokensToServers([ server ])
 
     const username = 'user1'
     const password = 'my super password'
-    await createUser(server.url, server.accessToken, username, password)
+    await createUser({ url: server.url, accessToken: server.accessToken, username: username, password: password })
     userAccessToken = await userLogin(server, { username, password })
 
     const res = await uploadVideo(server.url, server.accessToken, {})
@@ -191,11 +188,6 @@ describe('Test video abuses API validators', function () {
   })
 
   after(async function () {
-    killallServers([ server ])
-
-    // Keep the logs if the test failed
-    if (this['ok']) {
-      await flushTests()
-    }
+    await cleanupTests([ server ])
   })
 })
diff --git a/server/tests/api/check-params/video-blacklist.ts b/server/tests/api/check-params/video-blacklist.ts
index 6b82643f4..6466888fb 100644
--- a/server/tests/api/check-params/video-blacklist.ts
+++ b/server/tests/api/check-params/video-blacklist.ts
@@ -3,6 +3,7 @@
 import 'mocha'
 
 import {
+  cleanupTests,
   createUser,
   doubleFollow,
   flushAndRunMultipleServers,
@@ -18,13 +19,13 @@ import {
   setAccessTokensToServers,
   uploadVideo,
   userLogin, waitJobs
-} from '../../../../shared/utils'
+} from '../../../../shared/extra-utils'
 import {
   checkBadCountPagination,
   checkBadSortPagination,
   checkBadStartPagination
-} from '../../../../shared/utils/requests/check-api-params'
-import { VideoDetails } from '../../../../shared/models/videos'
+} from '../../../../shared/extra-utils/requests/check-api-params'
+import { VideoDetails, VideoBlacklistType } from '../../../../shared/models/videos'
 import { expect } from 'chai'
 
 describe('Test video blacklist API validators', function () {
@@ -39,7 +40,6 @@ describe('Test video blacklist API validators', function () {
   before(async function () {
     this.timeout(120000)
 
-    await flushTests()
     servers = await flushAndRunMultipleServers(2)
 
     await setAccessTokensToServers(servers)
@@ -48,14 +48,14 @@ describe('Test video blacklist API validators', function () {
     {
       const username = 'user1'
       const password = 'my super password'
-      await createUser(servers[0].url, servers[0].accessToken, username, password)
+      await createUser({ url: servers[ 0 ].url, accessToken: servers[ 0 ].accessToken, username: username, password: password })
       userAccessToken1 = await userLogin(servers[0], { username, password })
     }
 
     {
       const username = 'user2'
       const password = 'my super password'
-      await createUser(servers[0].url, servers[0].accessToken, username, password)
+      await createUser({ url: servers[ 0 ].url, accessToken: servers[ 0 ].accessToken, username: username, password: password })
       userAccessToken2 = await userLogin(servers[0], { username, password })
     }
 
@@ -220,11 +220,11 @@ describe('Test video blacklist API validators', function () {
     const basePath = '/api/v1/videos/blacklist/'
 
     it('Should fail with a non authenticated user', async function () {
-      await getBlacklistedVideosList(servers[0].url, 'fake token', 401)
+      await getBlacklistedVideosList({ url: servers[0].url, token: 'fake token', specialStatus: 401 })
     })
 
     it('Should fail with a non admin user', async function () {
-      await getBlacklistedVideosList(servers[0].url, userAccessToken2, 403)
+      await getBlacklistedVideosList({ url: servers[0].url, token: userAccessToken2, specialStatus: 403 })
     })
 
     it('Should fail with a bad start pagination', async function () {
@@ -238,14 +238,17 @@ describe('Test video blacklist API validators', function () {
     it('Should fail with an incorrect sort', async function () {
       await checkBadSortPagination(servers[0].url, basePath, servers[0].accessToken)
     })
+
+    it('Should fail with an invalid type', async function () {
+      await getBlacklistedVideosList({ url: servers[0].url, token: servers[0].accessToken, type: 0, specialStatus: 400 })
+    })
+
+    it('Should succeed with the correct parameters', async function () {
+      await getBlacklistedVideosList({ url: servers[0].url, token: servers[0].accessToken, type: VideoBlacklistType.MANUAL })
+    })
   })
 
   after(async function () {
-    killallServers(servers)
-
-    // Keep the logs if the test failed
-    if (this['ok']) {
-      await flushTests()
-    }
+    await cleanupTests(servers)
   })
 })
diff --git a/server/tests/api/check-params/video-captions.ts b/server/tests/api/check-params/video-captions.ts
index e4d36fd4f..4a373d43d 100644
--- a/server/tests/api/check-params/video-captions.ts
+++ b/server/tests/api/check-params/video-captions.ts
@@ -2,20 +2,19 @@
 
 import 'mocha'
 import {
+  cleanupTests,
   createUser,
-  flushTests,
-  killallServers,
+  flushAndRunServer,
   makeDeleteRequest,
   makeGetRequest,
   makeUploadRequest,
-  runServer,
   ServerInfo,
   setAccessTokensToServers,
   uploadVideo,
   userLogin
-} from '../../../../shared/utils'
+} from '../../../../shared/extra-utils'
 import { join } from 'path'
-import { createVideoCaption } from '../../../../shared/utils/videos/video-captions'
+import { createVideoCaption } from '../../../../shared/extra-utils/videos/video-captions'
 
 describe('Test video captions API validator', function () {
   const path = '/api/v1/videos/'
@@ -29,9 +28,7 @@ describe('Test video captions API validator', function () {
   before(async function () {
     this.timeout(30000)
 
-    await flushTests()
-
-    server = await runServer(1)
+    server = await flushAndRunServer(1)
 
     await setAccessTokensToServers([ server ])
 
@@ -45,7 +42,7 @@ describe('Test video captions API validator', function () {
         username: 'user1',
         password: 'my super password'
       }
-      await createUser(server.url, server.accessToken, user.username, user.password)
+      await createUser({ url: server.url, accessToken: server.accessToken, username: user.username, password: user.password })
       userAccessToken = await userLogin(server, user)
     }
   })
@@ -272,11 +269,6 @@ describe('Test video captions API validator', function () {
   })
 
   after(async function () {
-    killallServers([ server ])
-
-    // Keep the logs if the test failed
-    if (this['ok']) {
-      await flushTests()
-    }
+    await cleanupTests([ server ])
   })
 })
diff --git a/server/tests/api/check-params/video-channels.ts b/server/tests/api/check-params/video-channels.ts
index 14e4deaf7..65bc20613 100644
--- a/server/tests/api/check-params/video-channels.ts
+++ b/server/tests/api/check-params/video-channels.ts
@@ -4,29 +4,25 @@ import * as chai from 'chai'
 import { omit } from 'lodash'
 import 'mocha'
 import {
+  cleanupTests,
   createUser,
   deleteVideoChannel,
-  flushTests,
+  flushAndRunServer,
   getAccountVideoChannelsList,
-  getMyUserInformation,
-  getVideoChannelsList,
   immutableAssign,
-  killallServers,
   makeGetRequest,
   makePostBodyRequest,
   makePutBodyRequest,
   makeUploadRequest,
-  runServer,
   ServerInfo,
   setAccessTokensToServers,
   userLogin
-} from '../../../../shared/utils'
+} from '../../../../shared/extra-utils'
 import {
   checkBadCountPagination,
   checkBadSortPagination,
   checkBadStartPagination
-} from '../../../../shared/utils/requests/check-api-params'
-import { User } from '../../../../shared/models/users'
+} from '../../../../shared/extra-utils/requests/check-api-params'
 import { join } from 'path'
 
 const expect = chai.expect
@@ -41,9 +37,7 @@ describe('Test video channels API validator', function () {
   before(async function () {
     this.timeout(30000)
 
-    await flushTests()
-
-    server = await runServer(1)
+    server = await flushAndRunServer(1)
 
     await setAccessTokensToServers([ server ])
 
@@ -53,7 +47,7 @@ describe('Test video channels API validator', function () {
     }
 
     {
-      await createUser(server.url, server.accessToken, user.username, user.password)
+      await createUser({ url: server.url, accessToken: server.accessToken, username: user.username, password: user.password })
       accessTokenUser = await userLogin(server, user)
     }
   })
@@ -313,11 +307,6 @@ describe('Test video channels API validator', function () {
   })
 
   after(async function () {
-    killallServers([ server ])
-
-    // Keep the logs if the test failed
-    if (this['ok']) {
-      await flushTests()
-    }
+    await cleanupTests([ server ])
   })
 })
diff --git a/server/tests/api/check-params/video-comments.ts b/server/tests/api/check-params/video-comments.ts
index 5981780ed..5cf90bacc 100644
--- a/server/tests/api/check-params/video-comments.ts
+++ b/server/tests/api/check-params/video-comments.ts
@@ -3,16 +3,23 @@
 import * as chai from 'chai'
 import 'mocha'
 import {
+  cleanupTests,
   createUser,
-  flushTests, killallServers, makeDeleteRequest, makeGetRequest, makePostBodyRequest, runServer, ServerInfo, setAccessTokensToServers,
-  uploadVideo, userLogin
-} from '../../../../shared/utils'
+  flushAndRunServer,
+  makeDeleteRequest,
+  makeGetRequest,
+  makePostBodyRequest,
+  ServerInfo,
+  setAccessTokensToServers,
+  uploadVideo,
+  userLogin
+} from '../../../../shared/extra-utils'
 import {
   checkBadCountPagination,
   checkBadSortPagination,
   checkBadStartPagination
-} from '../../../../shared/utils/requests/check-api-params'
-import { addVideoCommentThread } from '../../../../shared/utils/videos/video-comments'
+} from '../../../../shared/extra-utils/requests/check-api-params'
+import { addVideoCommentThread } from '../../../../shared/extra-utils/videos/video-comments'
 
 const expect = chai.expect
 
@@ -29,9 +36,7 @@ describe('Test video comments API validator', function () {
   before(async function () {
     this.timeout(30000)
 
-    await flushTests()
-
-    server = await runServer(1)
+    server = await flushAndRunServer(1)
 
     await setAccessTokensToServers([ server ])
 
@@ -52,7 +57,7 @@ describe('Test video comments API validator', function () {
         username: 'user1',
         password: 'my super password'
       }
-      await createUser(server.url, server.accessToken, user.username, user.password)
+      await createUser({ url: server.url, accessToken: server.accessToken, username: user.username, password: user.password })
       userAccessToken = await userLogin(server, user)
     }
   })
@@ -254,11 +259,6 @@ describe('Test video comments API validator', function () {
   })
 
   after(async function () {
-    killallServers([ server ])
-
-    // Keep the logs if the test failed
-    if (this['ok']) {
-      await flushTests()
-    }
+    await cleanupTests([ server ])
   })
 })
diff --git a/server/tests/api/check-params/video-imports.ts b/server/tests/api/check-params/video-imports.ts
index 7bf187007..8ff115e7b 100644
--- a/server/tests/api/check-params/video-imports.ts
+++ b/server/tests/api/check-params/video-imports.ts
@@ -5,26 +5,25 @@ import 'mocha'
 import { join } from 'path'
 import { VideoPrivacy } from '../../../../shared/models/videos/video-privacy.enum'
 import {
+  cleanupTests,
   createUser,
-  flushTests,
+  flushAndRunServer,
   getMyUserInformation,
   immutableAssign,
-  killallServers,
   makeGetRequest,
   makePostBodyRequest,
   makeUploadRequest,
-  runServer,
   ServerInfo,
   setAccessTokensToServers,
   updateCustomSubConfig,
   userLogin
-} from '../../../../shared/utils'
+} from '../../../../shared/extra-utils'
 import {
   checkBadCountPagination,
   checkBadSortPagination,
   checkBadStartPagination
-} from '../../../../shared/utils/requests/check-api-params'
-import { getMagnetURI, getYoutubeVideoUrl } from '../../../../shared/utils/videos/video-imports'
+} from '../../../../shared/extra-utils/requests/check-api-params'
+import { getMagnetURI, getYoutubeVideoUrl } from '../../../../shared/extra-utils/videos/video-imports'
 
 describe('Test video imports API validator', function () {
   const path = '/api/v1/videos/imports'
@@ -38,15 +37,13 @@ describe('Test video imports API validator', function () {
   before(async function () {
     this.timeout(30000)
 
-    await flushTests()
-
-    server = await runServer(1)
+    server = await flushAndRunServer(1)
 
     await setAccessTokensToServers([ server ])
 
     const username = 'user1'
     const password = 'my super password'
-    await createUser(server.url, server.accessToken, username, password)
+    await createUser({ url: server.url, accessToken: server.accessToken, username: username, password: password })
     userAccessToken = await userLogin(server, { username, password })
 
     {
@@ -88,6 +85,7 @@ describe('Test video imports API validator', function () {
         language: 'pt',
         nsfw: false,
         commentsEnabled: true,
+        downloadEnabled: true,
         waitTranscoding: true,
         description: 'my super description',
         support: 'my super support text',
@@ -166,7 +164,7 @@ describe('Test video imports API validator', function () {
         username: 'fake',
         password: 'fake_password'
       }
-      await createUser(server.url, server.accessToken, user.username, user.password)
+      await createUser({ url: server.url, accessToken: server.accessToken, username: user.username, password: user.password })
 
       const accessTokenUser = await userLogin(server, user)
       const res = await getMyUserInformation(server.url, accessTokenUser)
@@ -313,11 +311,6 @@ describe('Test video imports API validator', function () {
   })
 
   after(async function () {
-    killallServers([ server ])
-
-    // Keep the logs if the test failed
-    if (this['ok']) {
-      await flushTests()
-    }
+    await cleanupTests([ server ])
   })
 })
diff --git a/server/tests/api/check-params/video-playlists.ts b/server/tests/api/check-params/video-playlists.ts
new file mode 100644
index 000000000..b7b94c035
--- /dev/null
+++ b/server/tests/api/check-params/video-playlists.ts
@@ -0,0 +1,674 @@
+/* tslint:disable:no-unused-expression */
+
+import 'mocha'
+import {
+  addVideoInPlaylist,
+  cleanupTests,
+  createVideoPlaylist,
+  deleteVideoPlaylist,
+  flushAndRunServer,
+  generateUserAccessToken,
+  getAccountPlaylistsListWithToken,
+  getVideoPlaylist,
+  immutableAssign,
+  makeGetRequest,
+  removeVideoFromPlaylist,
+  reorderVideosPlaylist,
+  ServerInfo,
+  setAccessTokensToServers,
+  setDefaultVideoChannel,
+  updateVideoPlaylist,
+  updateVideoPlaylistElement,
+  uploadVideoAndGetId
+} from '../../../../shared/extra-utils'
+import {
+  checkBadCountPagination,
+  checkBadSortPagination,
+  checkBadStartPagination
+} from '../../../../shared/extra-utils/requests/check-api-params'
+import { VideoPlaylistPrivacy } from '../../../../shared/models/videos/playlist/video-playlist-privacy.model'
+import { VideoPlaylistType } from '../../../../shared/models/videos/playlist/video-playlist-type.model'
+
+describe('Test video playlists API validator', function () {
+  let server: ServerInfo
+  let userAccessToken: string
+  let playlistUUID: string
+  let privatePlaylistUUID: string
+  let watchLaterPlaylistId: number
+  let videoId: number
+  let videoId2: number
+
+  // ---------------------------------------------------------------
+
+  before(async function () {
+    this.timeout(30000)
+
+    server = await flushAndRunServer(1)
+
+    await setAccessTokensToServers([ server ])
+    await setDefaultVideoChannel([ server ])
+
+    userAccessToken = await generateUserAccessToken(server, 'user1')
+    videoId = (await uploadVideoAndGetId({ server, videoName: 'video 1' })).id
+    videoId2 = (await uploadVideoAndGetId({ server, videoName: 'video 2' })).id
+
+    {
+      const res = await getAccountPlaylistsListWithToken(server.url, server.accessToken, 'root',0, 5, VideoPlaylistType.WATCH_LATER)
+      watchLaterPlaylistId = res.body.data[0].id
+    }
+
+    {
+      const res = await createVideoPlaylist({
+        url: server.url,
+        token: server.accessToken,
+        playlistAttrs: {
+          displayName: 'super playlist',
+          privacy: VideoPlaylistPrivacy.PUBLIC,
+          videoChannelId: server.videoChannel.id
+        }
+      })
+      playlistUUID = res.body.videoPlaylist.uuid
+    }
+
+    {
+      const res = await createVideoPlaylist({
+        url: server.url,
+        token: server.accessToken,
+        playlistAttrs: {
+          displayName: 'private',
+          privacy: VideoPlaylistPrivacy.PRIVATE
+        }
+      })
+      privatePlaylistUUID = res.body.videoPlaylist.uuid
+    }
+  })
+
+  describe('When listing playlists', function () {
+    const globalPath = '/api/v1/video-playlists'
+    const accountPath = '/api/v1/accounts/root/video-playlists'
+    const videoChannelPath = '/api/v1/video-channels/root_channel/video-playlists'
+
+    it('Should fail with a bad start pagination', async function () {
+      await checkBadStartPagination(server.url, globalPath, server.accessToken)
+      await checkBadStartPagination(server.url, accountPath, server.accessToken)
+      await checkBadStartPagination(server.url, videoChannelPath, server.accessToken)
+    })
+
+    it('Should fail with a bad count pagination', async function () {
+      await checkBadCountPagination(server.url, globalPath, server.accessToken)
+      await checkBadCountPagination(server.url, accountPath, server.accessToken)
+      await checkBadCountPagination(server.url, videoChannelPath, server.accessToken)
+    })
+
+    it('Should fail with an incorrect sort', async function () {
+      await checkBadSortPagination(server.url, globalPath, server.accessToken)
+      await checkBadSortPagination(server.url, accountPath, server.accessToken)
+      await checkBadSortPagination(server.url, videoChannelPath, server.accessToken)
+    })
+
+    it('Should fail with a bad playlist type', async function () {
+      await makeGetRequest({ url: server.url, path: globalPath, query: { playlistType: 3 } })
+      await makeGetRequest({ url: server.url, path: accountPath, query: { playlistType: 3 } })
+      await makeGetRequest({ url: server.url, path: videoChannelPath, query: { playlistType: 3 } })
+    })
+
+    it('Should fail with a bad account parameter', async function () {
+      const accountPath = '/api/v1/accounts/root2/video-playlists'
+
+      await makeGetRequest({ url: server.url, path: accountPath, statusCodeExpected: 404, token: server.accessToken })
+    })
+
+    it('Should fail with a bad video channel parameter', async function () {
+      const accountPath = '/api/v1/video-channels/bad_channel/video-playlists'
+
+      await makeGetRequest({ url: server.url, path: accountPath, statusCodeExpected: 404, token: server.accessToken })
+    })
+
+    it('Should success with the correct parameters', async function () {
+      await makeGetRequest({ url: server.url, path: globalPath, statusCodeExpected: 200, token: server.accessToken })
+      await makeGetRequest({ url: server.url, path: accountPath, statusCodeExpected: 200, token: server.accessToken })
+      await makeGetRequest({ url: server.url, path: videoChannelPath, statusCodeExpected: 200, token: server.accessToken })
+    })
+  })
+
+  describe('When listing videos of a playlist', function () {
+    const path = '/api/v1/video-playlists'
+
+    it('Should fail with a bad start pagination', async function () {
+      await checkBadStartPagination(server.url, path, server.accessToken)
+    })
+
+    it('Should fail with a bad count pagination', async function () {
+      await checkBadCountPagination(server.url, path, server.accessToken)
+    })
+
+    it('Should fail with a bad filter', async function () {
+      await checkBadSortPagination(server.url, path, server.accessToken)
+    })
+  })
+
+  describe('When getting a video playlist', function () {
+    it('Should fail with a bad id or uuid', async function () {
+      await getVideoPlaylist(server.url, 'toto', 400)
+    })
+
+    it('Should fail with an unknown playlist', async function () {
+      await getVideoPlaylist(server.url, 42, 404)
+    })
+
+    it('Should fail to get an unlisted playlist with the number id', async function () {
+      const res = await createVideoPlaylist({
+        url: server.url,
+        token: server.accessToken,
+        playlistAttrs: {
+          displayName: 'super playlist',
+          privacy: VideoPlaylistPrivacy.UNLISTED
+        }
+      })
+      const playlist = res.body.videoPlaylist
+
+      await getVideoPlaylist(server.url, playlist.id, 404)
+      await getVideoPlaylist(server.url, playlist.uuid, 200)
+    })
+
+    it('Should succeed with the correct params', async function () {
+      await getVideoPlaylist(server.url, playlistUUID, 200)
+    })
+  })
+
+  describe('When creating/updating a video playlist', function () {
+    const getBase = (playlistAttrs: any = {}, wrapper: any = {}) => {
+      return Object.assign({
+        expectedStatus: 400,
+        url: server.url,
+        token: server.accessToken,
+        playlistAttrs: Object.assign({
+          displayName: 'display name',
+          privacy: VideoPlaylistPrivacy.UNLISTED,
+          thumbnailfile: 'thumbnail.jpg',
+          videoChannelId: server.videoChannel.id
+        }, playlistAttrs)
+      }, wrapper)
+    }
+    const getUpdate = (params: any, playlistId: number | string) => {
+      return immutableAssign(params, { playlistId: playlistId })
+    }
+
+    it('Should fail with an unauthenticated user', async function () {
+      const params = getBase({}, { token: null, expectedStatus: 401 })
+
+      await createVideoPlaylist(params)
+      await updateVideoPlaylist(getUpdate(params, playlistUUID))
+    })
+
+    it('Should fail without displayName', async function () {
+      const params = getBase({ displayName: undefined })
+
+      await createVideoPlaylist(params)
+      await updateVideoPlaylist(getUpdate(params, playlistUUID))
+    })
+
+    it('Should fail with an incorrect display name', async function () {
+      const params = getBase({ displayName: 's'.repeat(300) })
+
+      await createVideoPlaylist(params)
+      await updateVideoPlaylist(getUpdate(params, playlistUUID))
+    })
+
+    it('Should fail with an incorrect description', async function () {
+      const params = getBase({ description: 't' })
+
+      await createVideoPlaylist(params)
+      await updateVideoPlaylist(getUpdate(params, playlistUUID))
+    })
+
+    it('Should fail with an incorrect privacy', async function () {
+      const params = getBase({ privacy: 45 })
+
+      await createVideoPlaylist(params)
+      await updateVideoPlaylist(getUpdate(params, playlistUUID))
+    })
+
+    it('Should fail with an unknown video channel id', async function () {
+      const params = getBase({ videoChannelId: 42 }, { expectedStatus: 404 })
+
+      await createVideoPlaylist(params)
+      await updateVideoPlaylist(getUpdate(params, playlistUUID))
+    })
+
+    it('Should fail with an incorrect thumbnail file', async function () {
+      const params = getBase({ thumbnailfile: 'avatar.png' })
+
+      await createVideoPlaylist(params)
+      await updateVideoPlaylist(getUpdate(params, playlistUUID))
+    })
+
+    it('Should fail to set "public" a playlist not assigned to a channel', async function () {
+      const params = getBase({ privacy: VideoPlaylistPrivacy.PUBLIC, videoChannelId: undefined })
+      const params2 = getBase({ privacy: VideoPlaylistPrivacy.PUBLIC, videoChannelId: 'null' })
+      const params3 = getBase({ privacy: undefined, videoChannelId: 'null' })
+
+      await createVideoPlaylist(params)
+      await createVideoPlaylist(params2)
+      await updateVideoPlaylist(getUpdate(params, privatePlaylistUUID))
+      await updateVideoPlaylist(getUpdate(params2, playlistUUID))
+      await updateVideoPlaylist(getUpdate(params3, playlistUUID))
+    })
+
+    it('Should fail with an unknown playlist to update', async function () {
+      await updateVideoPlaylist(getUpdate(
+        getBase({}, { expectedStatus: 404 }),
+        42
+      ))
+    })
+
+    it('Should fail to update a playlist of another user', async function () {
+      await updateVideoPlaylist(getUpdate(
+        getBase({}, { token: userAccessToken, expectedStatus: 403 }),
+        playlistUUID
+      ))
+    })
+
+    it('Should fail to update to private a public/unlisted playlist', async function () {
+      const params = getBase({ privacy: VideoPlaylistPrivacy.PUBLIC }, { expectedStatus: 200 })
+
+      const res = await createVideoPlaylist(params)
+      const playlist = res.body.videoPlaylist
+
+      const paramsUpdate = getBase({ privacy: VideoPlaylistPrivacy.PRIVATE }, { expectedStatus: 400 })
+
+      await updateVideoPlaylist(getUpdate(paramsUpdate, playlist.id))
+    })
+
+    it('Should fail to update the watch later playlist', async function () {
+      await updateVideoPlaylist(getUpdate(
+        getBase({}, { expectedStatus: 400 }),
+        watchLaterPlaylistId
+      ))
+    })
+
+    it('Should succeed with the correct params', async function () {
+      {
+        const params = getBase({}, { expectedStatus: 200 })
+        await createVideoPlaylist(params)
+      }
+
+      {
+        const params = getBase({}, { expectedStatus: 204 })
+        await updateVideoPlaylist(getUpdate(params, playlistUUID))
+      }
+    })
+  })
+
+  describe('When adding an element in a playlist', function () {
+    const getBase = (elementAttrs: any = {}, wrapper: any = {}) => {
+      return Object.assign({
+        expectedStatus: 400,
+        url: server.url,
+        token: server.accessToken,
+        playlistId: playlistUUID,
+        elementAttrs: Object.assign({
+          videoId: videoId,
+          startTimestamp: 2,
+          stopTimestamp: 3
+        }, elementAttrs)
+      }, wrapper)
+    }
+
+    it('Should fail with an unauthenticated user', async function () {
+      const params = getBase({}, { token: null, expectedStatus: 401 })
+      await addVideoInPlaylist(params)
+    })
+
+    it('Should fail with the playlist of another user', async function () {
+      const params = getBase({}, { token: userAccessToken, expectedStatus: 403 })
+      await addVideoInPlaylist(params)
+    })
+
+    it('Should fail with an unknown or incorrect playlist id', async function () {
+      {
+        const params = getBase({}, { playlistId: 'toto' })
+        await addVideoInPlaylist(params)
+      }
+
+      {
+        const params = getBase({}, { playlistId: 42, expectedStatus: 404 })
+        await addVideoInPlaylist(params)
+      }
+    })
+
+    it('Should fail with an unknown or incorrect video id', async function () {
+      const params = getBase({ videoId: 42 }, { expectedStatus: 404 })
+      await addVideoInPlaylist(params)
+    })
+
+    it('Should fail with a bad start/stop timestamp', async function () {
+      {
+        const params = getBase({ startTimestamp: -42 })
+        await addVideoInPlaylist(params)
+      }
+
+      {
+        const params = getBase({ stopTimestamp: 'toto' as any })
+        await addVideoInPlaylist(params)
+      }
+    })
+
+    it('Succeed with the correct params', async function () {
+      const params = getBase({}, { expectedStatus: 200 })
+      await addVideoInPlaylist(params)
+    })
+
+    it('Should fail if the video was already added in the playlist', async function () {
+      const params = getBase({}, { expectedStatus: 409 })
+      await addVideoInPlaylist(params)
+    })
+  })
+
+  describe('When updating an element in a playlist', function () {
+    const getBase = (elementAttrs: any = {}, wrapper: any = {}) => {
+      return Object.assign({
+        url: server.url,
+        token: server.accessToken,
+        elementAttrs: Object.assign({
+          startTimestamp: 1,
+          stopTimestamp: 2
+        }, elementAttrs),
+        videoId: videoId,
+        playlistId: playlistUUID,
+        expectedStatus: 400
+      }, wrapper)
+    }
+
+    it('Should fail with an unauthenticated user', async function () {
+      const params = getBase({}, { token: null, expectedStatus: 401 })
+      await updateVideoPlaylistElement(params)
+    })
+
+    it('Should fail with the playlist of another user', async function () {
+      const params = getBase({}, { token: userAccessToken, expectedStatus: 403 })
+      await updateVideoPlaylistElement(params)
+    })
+
+    it('Should fail with an unknown or incorrect playlist id', async function () {
+      {
+        const params = getBase({}, { playlistId: 'toto' })
+        await updateVideoPlaylistElement(params)
+      }
+
+      {
+        const params = getBase({}, { playlistId: 42, expectedStatus: 404 })
+        await updateVideoPlaylistElement(params)
+      }
+    })
+
+    it('Should fail with an unknown or incorrect video id', async function () {
+      {
+        const params = getBase({}, { videoId: 'toto' })
+        await updateVideoPlaylistElement(params)
+      }
+
+      {
+        const params = getBase({}, { videoId: 42, expectedStatus: 404 })
+        await updateVideoPlaylistElement(params)
+      }
+    })
+
+    it('Should fail with a bad start/stop timestamp', async function () {
+      {
+        const params = getBase({ startTimestamp: 'toto' as any })
+        await updateVideoPlaylistElement(params)
+      }
+
+      {
+        const params = getBase({ stopTimestamp: -42 })
+        await updateVideoPlaylistElement(params)
+      }
+    })
+
+    it('Should fail with an unknown element', async function () {
+      const params = getBase({}, { videoId: videoId2, expectedStatus: 404 })
+      await updateVideoPlaylistElement(params)
+    })
+
+    it('Succeed with the correct params', async function () {
+      const params = getBase({}, { expectedStatus: 204 })
+      await updateVideoPlaylistElement(params)
+    })
+  })
+
+  describe('When reordering elements of a playlist', function () {
+    let videoId3: number
+    let videoId4: number
+
+    const getBase = (elementAttrs: any = {}, wrapper: any = {}) => {
+      return Object.assign({
+        url: server.url,
+        token: server.accessToken,
+        playlistId: playlistUUID,
+        elementAttrs: Object.assign({
+          startPosition: 1,
+          insertAfterPosition: 2,
+          reorderLength: 3
+        }, elementAttrs),
+        expectedStatus: 400
+      }, wrapper)
+    }
+
+    before(async function () {
+      videoId3 = (await uploadVideoAndGetId({ server, videoName: 'video 3' })).id
+      videoId4 = (await uploadVideoAndGetId({ server, videoName: 'video 4' })).id
+
+      for (let id of [ videoId3, videoId4 ]) {
+        await addVideoInPlaylist({
+          url: server.url,
+          token: server.accessToken,
+          playlistId: playlistUUID,
+          elementAttrs: { videoId: id }
+        })
+      }
+    })
+
+    it('Should fail with an unauthenticated user', async function () {
+      const params = getBase({}, { token: null, expectedStatus: 401 })
+      await reorderVideosPlaylist(params)
+    })
+
+    it('Should fail with the playlist of another user', async function () {
+      const params = getBase({}, { token: userAccessToken, expectedStatus: 403 })
+      await reorderVideosPlaylist(params)
+    })
+
+    it('Should fail with an invalid playlist', async function () {
+      {
+        const params = getBase({}, { playlistId: 'toto' })
+        await reorderVideosPlaylist(params)
+      }
+
+      {
+        const params = getBase({}, {  playlistId: 42, expectedStatus: 404 })
+        await reorderVideosPlaylist(params)
+      }
+    })
+
+    it('Should fail with an invalid start position', async function () {
+      {
+        const params = getBase({ startPosition: -1 })
+        await reorderVideosPlaylist(params)
+      }
+
+      {
+        const params = getBase({ startPosition: 'toto' as any })
+        await reorderVideosPlaylist(params)
+      }
+
+      {
+        const params = getBase({ startPosition: 42 })
+        await reorderVideosPlaylist(params)
+      }
+    })
+
+    it('Should fail with an invalid insert after position', async function () {
+      {
+        const params = getBase({ insertAfterPosition: 'toto' as any })
+        await reorderVideosPlaylist(params)
+      }
+
+      {
+        const params = getBase({ insertAfterPosition: -2 })
+        await reorderVideosPlaylist(params)
+      }
+
+      {
+        const params = getBase({ insertAfterPosition: 42 })
+        await reorderVideosPlaylist(params)
+      }
+    })
+
+    it('Should fail with an invalid reorder length', async function () {
+      {
+        const params = getBase({ reorderLength: 'toto' as any })
+        await reorderVideosPlaylist(params)
+      }
+
+      {
+        const params = getBase({ reorderLength: -2 })
+        await reorderVideosPlaylist(params)
+      }
+
+      {
+        const params = getBase({ reorderLength: 42 })
+        await reorderVideosPlaylist(params)
+      }
+    })
+
+    it('Succeed with the correct params', async function () {
+      const params = getBase({}, { expectedStatus: 204 })
+      await reorderVideosPlaylist(params)
+    })
+  })
+
+  describe('When checking exists in playlist endpoint', function () {
+    const path = '/api/v1/users/me/video-playlists/videos-exist'
+
+    it('Should fail with an unauthenticated user', async function () {
+      await makeGetRequest({
+        url: server.url,
+        path,
+        query: { videoIds: [ 1, 2 ] },
+        statusCodeExpected: 401
+      })
+    })
+
+    it('Should fail with invalid video ids', async function () {
+      await makeGetRequest({
+        url: server.url,
+        token: server.accessToken,
+        path,
+        query: { videoIds: 'toto' }
+      })
+
+      await makeGetRequest({
+        url: server.url,
+        token: server.accessToken,
+        path,
+        query: { videoIds: [ 'toto' ] }
+      })
+
+      await makeGetRequest({
+        url: server.url,
+        token: server.accessToken,
+        path,
+        query: { videoIds: [ 1, 'toto' ] }
+      })
+    })
+
+    it('Should succeed with the correct params', async function () {
+      await makeGetRequest({
+        url: server.url,
+        token: server.accessToken,
+        path,
+        query: { videoIds: [ 1, 2 ] },
+        statusCodeExpected: 200
+      })
+    })
+  })
+
+  describe('When deleting an element in a playlist', function () {
+    const getBase = (wrapper: any = {}) => {
+      return Object.assign({
+        url: server.url,
+        token: server.accessToken,
+        videoId: videoId,
+        playlistId: playlistUUID,
+        expectedStatus: 400
+      }, wrapper)
+    }
+
+    it('Should fail with an unauthenticated user', async function () {
+      const params = getBase({ token: null, expectedStatus: 401 })
+      await removeVideoFromPlaylist(params)
+    })
+
+    it('Should fail with the playlist of another user', async function () {
+      const params = getBase({ token: userAccessToken, expectedStatus: 403 })
+      await removeVideoFromPlaylist(params)
+    })
+
+    it('Should fail with an unknown or incorrect playlist id', async function () {
+      {
+        const params = getBase({ playlistId: 'toto' })
+        await removeVideoFromPlaylist(params)
+      }
+
+      {
+        const params = getBase({ playlistId: 42, expectedStatus: 404 })
+        await removeVideoFromPlaylist(params)
+      }
+    })
+
+    it('Should fail with an unknown or incorrect video id', async function () {
+      {
+        const params = getBase({ videoId: 'toto' })
+        await removeVideoFromPlaylist(params)
+      }
+
+      {
+        const params = getBase({ videoId: 42, expectedStatus: 404 })
+        await removeVideoFromPlaylist(params)
+      }
+    })
+
+    it('Should fail with an unknown element', async function () {
+      const params = getBase({ videoId: videoId2, expectedStatus: 404 })
+      await removeVideoFromPlaylist(params)
+    })
+
+    it('Succeed with the correct params', async function () {
+      const params = getBase({ expectedStatus: 204 })
+      await removeVideoFromPlaylist(params)
+    })
+  })
+
+  describe('When deleting a playlist', function () {
+    it('Should fail with an unknown playlist', async function () {
+      await deleteVideoPlaylist(server.url, server.accessToken, 42, 404)
+    })
+
+    it('Should fail with a playlist of another user', async function () {
+      await deleteVideoPlaylist(server.url, userAccessToken, playlistUUID, 403)
+    })
+
+    it('Should fail with the watch later playlist', async function () {
+      await deleteVideoPlaylist(server.url, server.accessToken, watchLaterPlaylistId, 400)
+    })
+
+    it('Should succeed with the correct params', async function () {
+      await deleteVideoPlaylist(server.url, server.accessToken, playlistUUID)
+    })
+  })
+
+  after(async function () {
+    await cleanupTests([ server ])
+  })
+})
diff --git a/server/tests/api/check-params/videos-filter.ts b/server/tests/api/check-params/videos-filter.ts
index e998c8a3d..babef8223 100644
--- a/server/tests/api/check-params/videos-filter.ts
+++ b/server/tests/api/check-params/videos-filter.ts
@@ -1,27 +1,27 @@
 /* tslint:disable:no-unused-expression */
 
-import * as chai from 'chai'
 import 'mocha'
 import {
+  cleanupTests,
   createUser,
-  flushTests,
-  killallServers,
+  createVideoPlaylist,
+  flushAndRunServer,
   makeGetRequest,
-  runServer,
   ServerInfo,
   setAccessTokensToServers,
+  setDefaultVideoChannel,
   userLogin
-} from '../../../../shared/utils'
+} from '../../../../shared/extra-utils'
 import { UserRole } from '../../../../shared/models/users'
+import { VideoPlaylistPrivacy } from '../../../../shared/models/videos/playlist/video-playlist-privacy.model'
 
-const expect = chai.expect
-
-async function testEndpoints (server: ServerInfo, token: string, filter: string, statusCodeExpected: number) {
+async function testEndpoints (server: ServerInfo, token: string, filter: string, playlistUUID: string, statusCodeExpected: number) {
   const paths = [
     '/api/v1/video-channels/root_channel/videos',
     '/api/v1/accounts/root/videos',
     '/api/v1/videos',
-    '/api/v1/search/videos'
+    '/api/v1/search/videos',
+    '/api/v1/video-playlists/' + playlistUUID + '/videos'
   ]
 
   for (const path of paths) {
@@ -41,55 +41,68 @@ describe('Test videos filters', function () {
   let server: ServerInfo
   let userAccessToken: string
   let moderatorAccessToken: string
+  let playlistUUID: string
 
   // ---------------------------------------------------------------
 
   before(async function () {
     this.timeout(30000)
 
-    await flushTests()
-
-    server = await runServer(1)
+    server = await flushAndRunServer(1)
 
     await setAccessTokensToServers([ server ])
+    await setDefaultVideoChannel([ server ])
 
     const user = { username: 'user1', password: 'my super password' }
-    await createUser(server.url, server.accessToken, user.username, user.password)
+    await createUser({ url: server.url, accessToken: server.accessToken, username: user.username, password: user.password })
     userAccessToken = await userLogin(server, user)
 
     const moderator = { username: 'moderator', password: 'my super password' }
     await createUser(
-      server.url,
-      server.accessToken,
-      moderator.username,
-      moderator.password,
-      undefined,
-      undefined,
-      UserRole.MODERATOR
+      {
+        url: server.url,
+        accessToken: server.accessToken,
+        username: moderator.username,
+        password: moderator.password,
+        videoQuota: undefined,
+        videoQuotaDaily: undefined,
+        role: UserRole.MODERATOR
+      }
     )
     moderatorAccessToken = await userLogin(server, moderator)
+
+    const res = await createVideoPlaylist({
+      url: server.url,
+      token: server.accessToken,
+      playlistAttrs: {
+        displayName: 'super playlist',
+        privacy: VideoPlaylistPrivacy.PUBLIC,
+        videoChannelId: server.videoChannel.id
+      }
+    })
+    playlistUUID = res.body.videoPlaylist.uuid
   })
 
   describe('When setting a video filter', function () {
 
     it('Should fail with a bad filter', async function () {
-      await testEndpoints(server, server.accessToken, 'bad-filter', 400)
+      await testEndpoints(server, server.accessToken, 'bad-filter', playlistUUID, 400)
     })
 
     it('Should succeed with a good filter', async function () {
-      await testEndpoints(server, server.accessToken,'local', 200)
+      await testEndpoints(server, server.accessToken,'local', playlistUUID, 200)
     })
 
     it('Should fail to list all-local with a simple user', async function () {
-      await testEndpoints(server, userAccessToken, 'all-local', 401)
+      await testEndpoints(server, userAccessToken, 'all-local', playlistUUID, 401)
     })
 
     it('Should succeed to list all-local with a moderator', async function () {
-      await testEndpoints(server, moderatorAccessToken, 'all-local', 200)
+      await testEndpoints(server, moderatorAccessToken, 'all-local', playlistUUID, 200)
     })
 
     it('Should succeed to list all-local with an admin', async function () {
-      await testEndpoints(server, server.accessToken, 'all-local', 200)
+      await testEndpoints(server, server.accessToken, 'all-local', playlistUUID, 200)
     })
 
     // Because we cannot authenticate the user on the RSS endpoint
@@ -104,7 +117,7 @@ describe('Test videos filters', function () {
       })
     })
 
-    it('Should succed on the feeds endpoint with the local filter', async function () {
+    it('Should succeed on the feeds endpoint with the local filter', async function () {
       await makeGetRequest({
         url: server.url,
         path: '/feeds/videos.json',
@@ -117,11 +130,6 @@ describe('Test videos filters', function () {
   })
 
   after(async function () {
-    killallServers([ server ])
-
-    // Keep the logs if the test failed
-    if (this['ok']) {
-      await flushTests()
-    }
+    await cleanupTests([ server ])
   })
 })
diff --git a/server/tests/api/check-params/videos-history.ts b/server/tests/api/check-params/videos-history.ts
index 8c079a956..3739e3fad 100644
--- a/server/tests/api/check-params/videos-history.ts
+++ b/server/tests/api/check-params/videos-history.ts
@@ -5,16 +5,15 @@ import 'mocha'
 import {
   checkBadCountPagination,
   checkBadStartPagination,
-  flushTests,
-  killallServers,
+  cleanupTests,
+  flushAndRunServer,
   makeGetRequest,
   makePostBodyRequest,
   makePutBodyRequest,
-  runServer,
   ServerInfo,
   setAccessTokensToServers,
   uploadVideo
-} from '../../../../shared/utils'
+} from '../../../../shared/extra-utils'
 
 const expect = chai.expect
 
@@ -29,9 +28,7 @@ describe('Test videos history API validator', function () {
   before(async function () {
     this.timeout(30000)
 
-    await flushTests()
-
-    server = await runServer(1)
+    server = await flushAndRunServer(1)
 
     await setAccessTokensToServers([ server ])
 
@@ -129,11 +126,6 @@ describe('Test videos history API validator', function () {
   })
 
   after(async function () {
-    killallServers([ server ])
-
-    // Keep the logs if the test failed
-    if (this['ok']) {
-      await flushTests()
-    }
+    await cleanupTests([ server ])
   })
 })
diff --git a/server/tests/api/check-params/videos.ts b/server/tests/api/check-params/videos.ts
index f26b91435..51e592a15 100644
--- a/server/tests/api/check-params/videos.ts
+++ b/server/tests/api/check-params/videos.ts
@@ -6,15 +6,28 @@ import 'mocha'
 import { join } from 'path'
 import { VideoPrivacy } from '../../../../shared/models/videos/video-privacy.enum'
 import {
-  createUser, flushTests, getMyUserInformation, getVideo, getVideosList, immutableAssign, killallServers, makeDeleteRequest,
-  makeGetRequest, makeUploadRequest, makePutBodyRequest, removeVideo, runServer, ServerInfo, setAccessTokensToServers, userLogin
-} from '../../../../shared/utils'
+  cleanupTests,
+  createUser,
+  flushAndRunServer,
+  getMyUserInformation,
+  getVideo,
+  getVideosList,
+  immutableAssign,
+  makeDeleteRequest,
+  makeGetRequest,
+  makePutBodyRequest,
+  makeUploadRequest,
+  removeVideo,
+  ServerInfo,
+  setAccessTokensToServers,
+  userLogin,
+  root
+} from '../../../../shared/extra-utils'
 import {
   checkBadCountPagination,
   checkBadSortPagination,
   checkBadStartPagination
-} from '../../../../shared/utils/requests/check-api-params'
-import { getAccountsList } from '../../../../shared/utils/users/accounts'
+} from '../../../../shared/extra-utils/requests/check-api-params'
 
 const expect = chai.expect
 
@@ -32,15 +45,13 @@ describe('Test videos API validator', function () {
   before(async function () {
     this.timeout(30000)
 
-    await flushTests()
-
-    server = await runServer(1)
+    server = await flushAndRunServer(1)
 
     await setAccessTokensToServers([ server ])
 
     const username = 'user1'
     const password = 'my super password'
-    await createUser(server.url, server.accessToken, username, password)
+    await createUser({ url: server.url, accessToken: server.accessToken, username: username, password: password })
     userAccessToken = await userLogin(server, { username, password })
 
     {
@@ -167,7 +178,7 @@ describe('Test videos API validator', function () {
   describe('When adding a video', function () {
     let baseCorrectParams
     const baseCorrectAttaches = {
-      'videofile': join(__dirname, '..', '..', 'fixtures', 'video_short.webm')
+      'videofile': join(root(), 'server', 'tests', 'fixtures', 'video_short.webm')
     }
 
     before(function () {
@@ -179,12 +190,14 @@ describe('Test videos API validator', function () {
         language: 'pt',
         nsfw: false,
         commentsEnabled: true,
+        downloadEnabled: true,
         waitTranscoding: true,
         description: 'my super description',
         support: 'my super support text',
         tags: [ 'tag1', 'tag2' ],
         privacy: VideoPrivacy.PUBLIC,
-        channelId: channelId
+        channelId: channelId,
+        originallyPublishedAt: new Date().toISOString()
       }
     })
 
@@ -262,7 +275,7 @@ describe('Test videos API validator', function () {
         username: 'fake',
         password: 'fake_password'
       }
-      await createUser(server.url, server.accessToken, user.username, user.password)
+      await createUser({ url: server.url, accessToken: server.accessToken, username: user.username, password: user.password })
 
       const accessTokenUser = await userLogin(server, user)
       const res = await getMyUserInformation(server.url, accessTokenUser)
@@ -312,21 +325,28 @@ describe('Test videos API validator', function () {
       await makeUploadRequest({ url: server.url, path: path + '/upload', token: server.accessToken, fields, attaches })
     })
 
+    it('Should fail with a bad originally published at attribute', async function () {
+      const fields = immutableAssign(baseCorrectParams, { 'originallyPublishedAt': 'toto' })
+      const attaches = baseCorrectAttaches
+
+      await makeUploadRequest({ url: server.url, path: path + '/upload', token: server.accessToken, fields, attaches })
+    })
+
     it('Should fail without an input file', async function () {
       const fields = baseCorrectParams
       const attaches = {}
       await makeUploadRequest({ url: server.url, path: path + '/upload', token: server.accessToken, fields, attaches })
     })
 
-    it('Should fail without an incorrect input file', async function () {
+    it('Should fail with an incorrect input file', async function () {
       const fields = baseCorrectParams
       let attaches = {
-        'videofile': join(__dirname, '..', '..', 'fixtures', 'video_short_fake.webm')
+        'videofile': join(root(), 'server', 'tests', 'fixtures', 'video_short_fake.webm')
       }
       await makeUploadRequest({ url: server.url, path: path + '/upload', token: server.accessToken, fields, attaches })
 
       attaches = {
-        'videofile': join(__dirname, '..', '..', 'fixtures', 'video_short.mkv')
+        'videofile': join(root(), 'server', 'tests', 'fixtures', 'video_short.mkv')
       }
       await makeUploadRequest({ url: server.url, path: path + '/upload', token: server.accessToken, fields, attaches })
     })
@@ -334,8 +354,8 @@ describe('Test videos API validator', function () {
     it('Should fail with an incorrect thumbnail file', async function () {
       const fields = baseCorrectParams
       const attaches = {
-        'thumbnailfile': join(__dirname, '..', '..', 'fixtures', 'avatar.png'),
-        'videofile': join(__dirname, '..', '..', 'fixtures', 'video_short.mp4')
+        'thumbnailfile': join(root(), 'server', 'tests', 'fixtures', 'avatar.png'),
+        'videofile': join(root(), 'server', 'tests', 'fixtures', 'video_short.mp4')
       }
 
       await makeUploadRequest({ url: server.url, path: path + '/upload', token: server.accessToken, fields, attaches })
@@ -344,8 +364,8 @@ describe('Test videos API validator', function () {
     it('Should fail with a big thumbnail file', async function () {
       const fields = baseCorrectParams
       const attaches = {
-        'thumbnailfile': join(__dirname, '..', '..', 'fixtures', 'avatar-big.png'),
-        'videofile': join(__dirname, '..', '..', 'fixtures', 'video_short.mp4')
+        'thumbnailfile': join(root(), 'server', 'tests', 'fixtures', 'avatar-big.png'),
+        'videofile': join(root(), 'server', 'tests', 'fixtures', 'video_short.mp4')
       }
 
       await makeUploadRequest({ url: server.url, path: path + '/upload', token: server.accessToken, fields, attaches })
@@ -354,8 +374,8 @@ describe('Test videos API validator', function () {
     it('Should fail with an incorrect preview file', async function () {
       const fields = baseCorrectParams
       const attaches = {
-        'previewfile': join(__dirname, '..', '..', 'fixtures', 'avatar.png'),
-        'videofile': join(__dirname, '..', '..', 'fixtures', 'video_short.mp4')
+        'previewfile': join(root(), 'server', 'tests', 'fixtures', 'avatar.png'),
+        'videofile': join(root(), 'server', 'tests', 'fixtures', 'video_short.mp4')
       }
 
       await makeUploadRequest({ url: server.url, path: path + '/upload', token: server.accessToken, fields, attaches })
@@ -364,8 +384,8 @@ describe('Test videos API validator', function () {
     it('Should fail with a big preview file', async function () {
       const fields = baseCorrectParams
       const attaches = {
-        'previewfile': join(__dirname, '..', '..', 'fixtures', 'avatar-big.png'),
-        'videofile': join(__dirname, '..', '..', 'fixtures', 'video_short.mp4')
+        'previewfile': join(root(), 'server', 'tests', 'fixtures', 'avatar-big.png'),
+        'videofile': join(root(), 'server', 'tests', 'fixtures', 'video_short.mp4')
       }
 
       await makeUploadRequest({ url: server.url, path: path + '/upload', token: server.accessToken, fields, attaches })
@@ -390,7 +410,7 @@ describe('Test videos API validator', function () {
 
       {
         const attaches = immutableAssign(baseCorrectAttaches, {
-          videofile: join(__dirname, '..', '..', 'fixtures', 'video_short.mp4')
+          videofile: join(root(), 'server', 'tests', 'fixtures', 'video_short.mp4')
         })
 
         await makeUploadRequest({
@@ -405,7 +425,7 @@ describe('Test videos API validator', function () {
 
       {
         const attaches = immutableAssign(baseCorrectAttaches, {
-          videofile: join(__dirname, '..', '..', 'fixtures', 'video_short.ogv')
+          videofile: join(root(), 'server', 'tests', 'fixtures', 'video_short.ogv')
         })
 
         await makeUploadRequest({
@@ -428,6 +448,7 @@ describe('Test videos API validator', function () {
       language: 'pt',
       nsfw: false,
       commentsEnabled: false,
+      downloadEnabled: false,
       description: 'my super description',
       privacy: VideoPrivacy.PUBLIC,
       tags: [ 'tag1', 'tag2' ]
@@ -532,10 +553,16 @@ describe('Test videos API validator', function () {
       await makePutBodyRequest({ url: server.url, path: path + videoId, token: server.accessToken, fields })
     })
 
+    it('Should fail with a bad originally published at param', async function () {
+      const fields = immutableAssign(baseCorrectParams, { originallyPublishedAt: 'toto' })
+
+      await makePutBodyRequest({ url: server.url, path: path + videoId, token: server.accessToken, fields })
+    })
+
     it('Should fail with an incorrect thumbnail file', async function () {
       const fields = baseCorrectParams
       const attaches = {
-        'thumbnailfile': join(__dirname, '..', '..', 'fixtures', 'avatar.png')
+        'thumbnailfile': join(root(), 'server', 'tests', 'fixtures', 'avatar.png')
       }
 
       await makeUploadRequest({
@@ -551,7 +578,7 @@ describe('Test videos API validator', function () {
     it('Should fail with a big thumbnail file', async function () {
       const fields = baseCorrectParams
       const attaches = {
-        'thumbnailfile': join(__dirname, '..', '..', 'fixtures', 'avatar-big.png')
+        'thumbnailfile': join(root(), 'server', 'tests', 'fixtures', 'avatar-big.png')
       }
 
       await makeUploadRequest({
@@ -567,7 +594,7 @@ describe('Test videos API validator', function () {
     it('Should fail with an incorrect preview file', async function () {
       const fields = baseCorrectParams
       const attaches = {
-        'previewfile': join(__dirname, '..', '..', 'fixtures', 'avatar.png')
+        'previewfile': join(root(), 'server', 'tests', 'fixtures', 'avatar.png')
       }
 
       await makeUploadRequest({
@@ -583,7 +610,7 @@ describe('Test videos API validator', function () {
     it('Should fail with a big preview file', async function () {
       const fields = baseCorrectParams
       const attaches = {
-        'previewfile': join(__dirname, '..', '..', 'fixtures', 'avatar-big.png')
+        'previewfile': join(root(), 'server', 'tests', 'fixtures', 'avatar-big.png')
       }
 
       await makeUploadRequest({
@@ -714,11 +741,6 @@ describe('Test videos API validator', function () {
   })
 
   after(async function () {
-    killallServers([ server ])
-
-    // Keep the logs if the test failed
-    if (this['ok']) {
-      await flushTests()
-    }
+    await cleanupTests([ server ])
   })
 })
diff --git a/server/tests/api/index-1.ts b/server/tests/api/index-1.ts
index 80d752f42..75cdd9025 100644
--- a/server/tests/api/index-1.ts
+++ b/server/tests/api/index-1.ts
@@ -1,2 +1,3 @@
 import './check-params'
+import './notifications'
 import './search'
diff --git a/server/tests/api/notifications/index.ts b/server/tests/api/notifications/index.ts
new file mode 100644
index 000000000..95ac8fc51
--- /dev/null
+++ b/server/tests/api/notifications/index.ts
@@ -0,0 +1 @@
+export * from './user-notifications'
diff --git a/server/tests/api/users/user-notifications.ts b/server/tests/api/notifications/user-notifications.ts
index 72b6a0aa2..f479e1785 100644
--- a/server/tests/api/users/user-notifications.ts
+++ b/server/tests/api/notifications/user-notifications.ts
@@ -4,25 +4,30 @@ import * as chai from 'chai'
 import 'mocha'
 import {
   addVideoToBlacklist,
+  cleanupTests,
   createUser,
   doubleFollow,
   flushAndRunMultipleServers,
-  flushTests,
+  follow,
+  getCustomConfig,
   getMyUserInformation,
+  getVideoCommentThreads,
+  getVideoThreadComments,
   immutableAssign,
   registerUser,
   removeVideoFromBlacklist,
   reportVideoAbuse,
+  updateCustomConfig,
   updateMyUser,
   updateVideo,
   updateVideoChannel,
   userLogin,
   wait
-} from '../../../../shared/utils'
-import { killallServers, ServerInfo, uploadVideo } from '../../../../shared/utils/index'
-import { setAccessTokensToServers } from '../../../../shared/utils/users/login'
-import { waitJobs } from '../../../../shared/utils/server/jobs'
-import { getUserNotificationSocket } from '../../../../shared/utils/socket/socket-io'
+} from '../../../../shared/extra-utils'
+import { ServerInfo, uploadVideo } from '../../../../shared/extra-utils/index'
+import { setAccessTokensToServers } from '../../../../shared/extra-utils/users/login'
+import { waitJobs } from '../../../../shared/extra-utils/server/jobs'
+import { getUserNotificationSocket } from '../../../../shared/extra-utils/socket/socket-io'
 import {
   checkCommentMention,
   CheckerBaseParams,
@@ -30,16 +35,18 @@ import {
   checkNewActorFollow,
   checkNewBlacklistOnMyVideo,
   checkNewCommentOnMyVideo,
+  checkNewInstanceFollower,
   checkNewVideoAbuseForModerators,
   checkNewVideoFromSubscription,
   checkUserRegistered,
+  checkVideoAutoBlacklistForModerators,
   checkVideoIsPublished,
   getLastNotification,
   getUserNotifications,
+  markAsReadAllNotifications,
   markAsReadNotifications,
-  updateMyNotificationSettings,
-  markAsReadAllNotifications
-} from '../../../../shared/utils/users/user-notifications'
+  updateMyNotificationSettings
+} from '../../../../shared/extra-utils/users/user-notifications'
 import {
   User,
   UserNotification,
@@ -47,13 +54,15 @@ import {
   UserNotificationSettingValue,
   UserNotificationType
 } from '../../../../shared/models/users'
-import { MockSmtpServer } from '../../../../shared/utils/miscs/email'
-import { addUserSubscription, removeUserSubscription } from '../../../../shared/utils/users/user-subscriptions'
+import { MockSmtpServer } from '../../../../shared/extra-utils/miscs/email'
+import { addUserSubscription, removeUserSubscription } from '../../../../shared/extra-utils/users/user-subscriptions'
 import { VideoPrivacy } from '../../../../shared/models/videos'
-import { getBadVideoUrl, getYoutubeVideoUrl, importVideo } from '../../../../shared/utils/videos/video-imports'
-import { addVideoCommentReply, addVideoCommentThread } from '../../../../shared/utils/videos/video-comments'
+import { getBadVideoUrl, getYoutubeVideoUrl, importVideo } from '../../../../shared/extra-utils/videos/video-imports'
+import { addVideoCommentReply, addVideoCommentThread } from '../../../../shared/extra-utils/videos/video-comments'
 import * as uuidv4 from 'uuid/v4'
-import { addAccountToAccountBlocklist, removeAccountFromAccountBlocklist } from '../../../../shared/utils/users/blocklist'
+import { addAccountToAccountBlocklist, removeAccountFromAccountBlocklist } from '../../../../shared/extra-utils/users/blocklist'
+import { CustomConfig } from '../../../../shared/models/server'
+import { VideoCommentThreadTree } from '../../../../shared/models/videos/video-comment.model'
 
 const expect = chai.expect
 
@@ -92,12 +101,14 @@ describe('Test users notifications', function () {
     newVideoFromSubscription: UserNotificationSettingValue.WEB | UserNotificationSettingValue.EMAIL,
     newCommentOnMyVideo: UserNotificationSettingValue.WEB | UserNotificationSettingValue.EMAIL,
     videoAbuseAsModerator: UserNotificationSettingValue.WEB | UserNotificationSettingValue.EMAIL,
+    videoAutoBlacklistAsModerator: UserNotificationSettingValue.WEB | UserNotificationSettingValue.EMAIL,
     blacklistOnMyVideo: UserNotificationSettingValue.WEB | UserNotificationSettingValue.EMAIL,
     myVideoImportFinished: UserNotificationSettingValue.WEB | UserNotificationSettingValue.EMAIL,
     myVideoPublished: UserNotificationSettingValue.WEB | UserNotificationSettingValue.EMAIL,
     commentMention: UserNotificationSettingValue.WEB | UserNotificationSettingValue.EMAIL,
     newFollow: UserNotificationSettingValue.WEB | UserNotificationSettingValue.EMAIL,
-    newUserRegistration: UserNotificationSettingValue.WEB | UserNotificationSettingValue.EMAIL
+    newUserRegistration: UserNotificationSettingValue.WEB | UserNotificationSettingValue.EMAIL,
+    newInstanceFollower: UserNotificationSettingValue.WEB | UserNotificationSettingValue.EMAIL
   }
 
   before(async function () {
@@ -105,14 +116,12 @@ describe('Test users notifications', function () {
 
     await MockSmtpServer.Instance.collectEmails(emails)
 
-    await flushTests()
-
     const overrideConfig = {
       smtp: {
         hostname: 'localhost'
       }
     }
-    servers = await flushAndRunMultipleServers(2, overrideConfig)
+    servers = await flushAndRunMultipleServers(3, overrideConfig)
 
     // Get the access tokens
     await setAccessTokensToServers(servers)
@@ -126,7 +135,13 @@ describe('Test users notifications', function () {
       username: 'user_1',
       password: 'super password'
     }
-    await createUser(servers[0].url, servers[0].accessToken, user.username, user.password, 10 * 1000 * 1000)
+    await createUser({
+      url: servers[ 0 ].url,
+      accessToken: servers[ 0 ].accessToken,
+      username: user.username,
+      password: user.password,
+      videoQuota: 10 * 1000 * 1000
+    })
     userAccessToken = await userLogin(servers[0], user)
 
     await updateMyNotificationSettings(servers[0].url, userAccessToken, allNotificationSettings)
@@ -165,6 +180,8 @@ describe('Test users notifications', function () {
     })
 
     it('Should not send notifications if the user does not follow the video publisher', async function () {
+      this.timeout(10000)
+
       await uploadVideoByLocalAccount(servers)
 
       const notification = await getLastNotification(servers[ 0 ].url, userAccessToken)
@@ -214,7 +231,7 @@ describe('Test users notifications', function () {
     })
 
     it('Should send a new video notification on a remote scheduled publication', async function () {
-      this.timeout(20000)
+      this.timeout(50000)
 
       // In 2 seconds
       let updateAt = new Date(new Date().getTime() + 2000)
@@ -236,7 +253,7 @@ describe('Test users notifications', function () {
     it('Should not send a notification before the video is published', async function () {
       this.timeout(20000)
 
-      let updateAt = new Date(new Date().getTime() + 100000)
+      let updateAt = new Date(new Date().getTime() + 1000000)
 
       const data = {
         privacy: VideoPrivacy.PRIVATE,
@@ -303,7 +320,7 @@ describe('Test users notifications', function () {
     })
 
     it('Should send a new video notification after a video import', async function () {
-      this.timeout(30000)
+      this.timeout(100000)
 
       const name = 'video import ' + uuidv4()
 
@@ -398,10 +415,14 @@ describe('Test users notifications', function () {
 
       await waitJobs(servers)
 
-      const resComment = await addVideoCommentThread(servers[1].url, servers[1].accessToken, uuid, 'comment')
-      const commentId = resComment.body.comment.id
+      await addVideoCommentThread(servers[1].url, servers[1].accessToken, uuid, 'comment')
 
       await waitJobs(servers)
+
+      const resComment = await getVideoCommentThreads(servers[0].url, uuid, 0, 5)
+      expect(resComment.body.data).to.have.lengthOf(1)
+      const commentId = resComment.body.data[0].id
+
       await checkNewCommentOnMyVideo(baseParams, uuid, commentId, commentId, 'presence')
     })
 
@@ -428,13 +449,24 @@ describe('Test users notifications', function () {
       const uuid = resVideo.body.video.uuid
       await waitJobs(servers)
 
-      const resThread = await addVideoCommentThread(servers[1].url, servers[1].accessToken, uuid, 'comment')
-      const threadId = resThread.body.comment.id
-
-      const resComment = await addVideoCommentReply(servers[1].url, servers[1].accessToken, uuid, threadId, 'reply')
-      const commentId = resComment.body.comment.id
+      {
+        const resThread = await addVideoCommentThread(servers[ 1 ].url, servers[ 1 ].accessToken, uuid, 'comment')
+        const threadId = resThread.body.comment.id
+        await addVideoCommentReply(servers[ 1 ].url, servers[ 1 ].accessToken, uuid, threadId, 'reply')
+      }
 
       await waitJobs(servers)
+
+      const resThread = await getVideoCommentThreads(servers[0].url, uuid, 0, 5)
+      expect(resThread.body.data).to.have.lengthOf(1)
+      const threadId = resThread.body.data[0].id
+
+      const resComments = await getVideoThreadComments(servers[0].url, uuid, threadId)
+      const tree = resComments.body as VideoCommentThreadTree
+
+      expect(tree.children).to.have.lengthOf(1)
+      const commentId = tree.children[0].comment.id
+
       await checkNewCommentOnMyVideo(baseParams, uuid, commentId, threadId, 'presence')
     })
   })
@@ -547,17 +579,27 @@ describe('Test users notifications', function () {
 
       await waitJobs(servers)
       const resThread = await addVideoCommentThread(servers[1].url, servers[1].accessToken, uuid, 'hello @user_1@localhost:9001 1')
-      const threadId = resThread.body.comment.id
+      const server2ThreadId = resThread.body.comment.id
 
       await waitJobs(servers)
-      await checkCommentMention(baseParams, uuid, threadId, threadId, 'super root 2 name', 'presence')
+
+      const resThread2 = await getVideoCommentThreads(servers[0].url, uuid, 0, 5)
+      expect(resThread2.body.data).to.have.lengthOf(1)
+      const server1ThreadId = resThread2.body.data[0].id
+      await checkCommentMention(baseParams, uuid, server1ThreadId, server1ThreadId, 'super root 2 name', 'presence')
 
       const text = '@user_1@localhost:9001 hello 2 @root@localhost:9001'
-      const resComment = await addVideoCommentReply(servers[1].url, servers[1].accessToken, uuid, threadId, text)
-      const commentId = resComment.body.comment.id
+      await addVideoCommentReply(servers[1].url, servers[1].accessToken, uuid, server2ThreadId, text)
 
       await waitJobs(servers)
-      await checkCommentMention(baseParams, uuid, commentId, threadId, 'super root 2 name', 'presence')
+
+      const resComments = await getVideoThreadComments(servers[0].url, uuid, server1ThreadId)
+      const tree = resComments.body as VideoCommentThreadTree
+
+      expect(tree.children).to.have.lengthOf(1)
+      const commentId = tree.children[0].comment.id
+
+      await checkCommentMention(baseParams, uuid, commentId, server1ThreadId, 'super root 2 name', 'presence')
     })
   })
 
@@ -658,6 +700,8 @@ describe('Test users notifications', function () {
     })
 
     it('Should not send a notification if transcoding is not enabled', async function () {
+      this.timeout(10000)
+
       const { name, uuid } = await uploadVideoByLocalAccount(servers)
       await waitJobs(servers)
 
@@ -731,6 +775,24 @@ describe('Test users notifications', function () {
       await wait(6000)
       await checkVideoIsPublished(baseParams, name, uuid, 'presence')
     })
+
+    it('Should not send a notification before the video is published', async function () {
+      this.timeout(20000)
+
+      let updateAt = new Date(new Date().getTime() + 100000)
+
+      const data = {
+        privacy: VideoPrivacy.PRIVATE,
+        scheduleUpdate: {
+          updateAt: updateAt.toISOString(),
+          privacy: VideoPrivacy.PUBLIC
+        }
+      }
+      const { name, uuid } = await uploadVideoByRemoteAccount(servers, data)
+
+      await wait(6000)
+      await checkVideoIsPublished(baseParams, name, uuid, 'absence')
+    })
   })
 
   describe('My video is imported', function () {
@@ -795,6 +857,8 @@ describe('Test users notifications', function () {
     })
 
     it('Should send a notification only to moderators when a user registers on the instance', async function () {
+      this.timeout(10000)
+
       await registerUser(servers[0].url, 'user_45', 'password')
 
       await waitJobs(servers)
@@ -806,6 +870,32 @@ describe('Test users notifications', function () {
     })
   })
 
+  describe('New instance follower', function () {
+    let baseParams: CheckerBaseParams
+
+    before(async () => {
+      baseParams = {
+        server: servers[0],
+        emails,
+        socketNotifications: adminNotifications,
+        token: servers[0].accessToken
+      }
+    })
+
+    it('Should send a notification only to admin when there is a new instance follower', async function () {
+      this.timeout(20000)
+
+      await follow(servers[2].url, [ servers[0].url ], servers[2].accessToken)
+
+      await waitJobs(servers)
+
+      await checkNewInstanceFollower(baseParams, 'localhost:9003', 'presence')
+
+      const userOverride = { socketNotifications: userNotifications, token: userAccessToken, check: { web: true, mail: false } }
+      await checkNewInstanceFollower(immutableAssign(baseParams, userOverride), 'localhost:9003', 'absence')
+    })
+  })
+
   describe('New actor follow', function () {
     let baseParams: CheckerBaseParams
     let myChannelName = 'super channel name'
@@ -863,6 +953,8 @@ describe('Test users notifications', function () {
     })
 
     it('Should notify when a local account is following one of our channel', async function () {
+      this.timeout(10000)
+
       await addUserSubscription(servers[0].url, servers[0].accessToken, 'user_1@localhost:9001')
 
       await waitJobs(servers)
@@ -871,6 +963,8 @@ describe('Test users notifications', function () {
     })
 
     it('Should notify when a remote account is following one of our channel', async function () {
+      this.timeout(10000)
+
       await addUserSubscription(servers[1].url, servers[1].accessToken, 'user_1@localhost:9001')
 
       await waitJobs(servers)
@@ -879,6 +973,180 @@ describe('Test users notifications', function () {
     })
   })
 
+  describe('Video-related notifications when video auto-blacklist is enabled', function () {
+    let userBaseParams: CheckerBaseParams
+    let adminBaseParamsServer1: CheckerBaseParams
+    let adminBaseParamsServer2: CheckerBaseParams
+    let videoUUID: string
+    let videoName: string
+    let currentCustomConfig: CustomConfig
+
+    before(async () => {
+
+      adminBaseParamsServer1 = {
+        server: servers[0],
+        emails,
+        socketNotifications: adminNotifications,
+        token: servers[0].accessToken
+      }
+
+      adminBaseParamsServer2 = {
+        server: servers[1],
+        emails,
+        socketNotifications: adminNotificationsServer2,
+        token: servers[1].accessToken
+      }
+
+      userBaseParams = {
+        server: servers[0],
+        emails,
+        socketNotifications: userNotifications,
+        token: userAccessToken
+      }
+
+      const resCustomConfig = await getCustomConfig(servers[0].url, servers[0].accessToken)
+      currentCustomConfig = resCustomConfig.body
+      const autoBlacklistTestsCustomConfig = immutableAssign(currentCustomConfig, {
+        autoBlacklist: {
+          videos: {
+            ofUsers: {
+              enabled: true
+            }
+          }
+        }
+      })
+      // enable transcoding otherwise own publish notification after transcoding not expected
+      autoBlacklistTestsCustomConfig.transcoding.enabled = true
+      await updateCustomConfig(servers[0].url, servers[0].accessToken, autoBlacklistTestsCustomConfig)
+
+      await addUserSubscription(servers[0].url, servers[0].accessToken, 'user_1_channel@localhost:9001')
+      await addUserSubscription(servers[1].url, servers[1].accessToken, 'user_1_channel@localhost:9001')
+
+    })
+
+    it('Should send notification to moderators on new video with auto-blacklist', async function () {
+      this.timeout(20000)
+
+      videoName = 'video with auto-blacklist ' + uuidv4()
+      const resVideo = await uploadVideo(servers[0].url, userAccessToken, { name: videoName })
+      videoUUID = resVideo.body.video.uuid
+
+      await waitJobs(servers)
+      await checkVideoAutoBlacklistForModerators(adminBaseParamsServer1, videoUUID, videoName, 'presence')
+    })
+
+    it('Should not send video publish notification if auto-blacklisted', async function () {
+      await checkVideoIsPublished(userBaseParams, videoName, videoUUID, 'absence')
+    })
+
+    it('Should not send a local user subscription notification if auto-blacklisted', async function () {
+      await checkNewVideoFromSubscription(adminBaseParamsServer1, videoName, videoUUID, 'absence')
+    })
+
+    it('Should not send a remote user subscription notification if auto-blacklisted', async function () {
+      await checkNewVideoFromSubscription(adminBaseParamsServer2, videoName, videoUUID, 'absence')
+    })
+
+    it('Should send video published and unblacklist after video unblacklisted', async function () {
+      this.timeout(20000)
+
+      await removeVideoFromBlacklist(servers[0].url, servers[0].accessToken, videoUUID)
+
+      await waitJobs(servers)
+
+      // FIXME: Can't test as two notifications sent to same user and util only checks last one
+      // One notification might be better anyways
+      // await checkNewBlacklistOnMyVideo(userBaseParams, videoUUID, videoName, 'unblacklist')
+      // await checkVideoIsPublished(userBaseParams, videoName, videoUUID, 'presence')
+    })
+
+    it('Should send a local user subscription notification after removed from blacklist', async function () {
+      await checkNewVideoFromSubscription(adminBaseParamsServer1, videoName, videoUUID, 'presence')
+    })
+
+    it('Should send a remote user subscription notification after removed from blacklist', async function () {
+      await checkNewVideoFromSubscription(adminBaseParamsServer2, videoName, videoUUID, 'presence')
+    })
+
+    it('Should send unblacklist but not published/subscription notes after unblacklisted if scheduled update pending', async function () {
+      this.timeout(20000)
+
+      let updateAt = new Date(new Date().getTime() + 100000)
+
+      const name = 'video with auto-blacklist and future schedule ' + uuidv4()
+
+      const data = {
+        name,
+        privacy: VideoPrivacy.PRIVATE,
+        scheduleUpdate: {
+          updateAt: updateAt.toISOString(),
+          privacy: VideoPrivacy.PUBLIC
+        }
+      }
+
+      const resVideo = await uploadVideo(servers[0].url, userAccessToken, data)
+      const uuid = resVideo.body.video.uuid
+
+      await removeVideoFromBlacklist(servers[0].url, servers[0].accessToken, uuid)
+
+      await waitJobs(servers)
+      await checkNewBlacklistOnMyVideo(userBaseParams, uuid, name, 'unblacklist')
+
+      // FIXME: Can't test absence as two notifications sent to same user and util only checks last one
+      // One notification might be better anyways
+      // await checkVideoIsPublished(userBaseParams, name, uuid, 'absence')
+
+      await checkNewVideoFromSubscription(adminBaseParamsServer1, name, uuid, 'absence')
+      await checkNewVideoFromSubscription(adminBaseParamsServer2, name, uuid, 'absence')
+    })
+
+    it('Should not send publish/subscription notifications after scheduled update if video still auto-blacklisted', async function () {
+      this.timeout(20000)
+
+      // In 2 seconds
+      let updateAt = new Date(new Date().getTime() + 2000)
+
+      const name = 'video with schedule done and still auto-blacklisted ' + uuidv4()
+
+      const data = {
+        name,
+        privacy: VideoPrivacy.PRIVATE,
+        scheduleUpdate: {
+          updateAt: updateAt.toISOString(),
+          privacy: VideoPrivacy.PUBLIC
+        }
+      }
+
+      const resVideo = await uploadVideo(servers[0].url, userAccessToken, data)
+      const uuid = resVideo.body.video.uuid
+
+      await wait(6000)
+      await checkVideoIsPublished(userBaseParams, name, uuid, 'absence')
+      await checkNewVideoFromSubscription(adminBaseParamsServer1, name, uuid, 'absence')
+      await checkNewVideoFromSubscription(adminBaseParamsServer2, name, uuid, 'absence')
+    })
+
+    it('Should not send a notification to moderators on new video without auto-blacklist', async function () {
+      this.timeout(20000)
+
+      const name = 'video without auto-blacklist ' + uuidv4()
+
+      // admin with blacklist right will not be auto-blacklisted
+      const resVideo = await uploadVideo(servers[0].url, servers[0].accessToken, { name })
+      const uuid = resVideo.body.video.uuid
+
+      await waitJobs(servers)
+      await checkVideoAutoBlacklistForModerators(adminBaseParamsServer1, uuid, name, 'absence')
+    })
+
+    after(async () => {
+      await updateCustomConfig(servers[0].url, servers[0].accessToken, currentCustomConfig)
+
+      await removeUserSubscription(servers[0].url, servers[0].accessToken, 'user_1_channel@localhost:9001')
+      await removeUserSubscription(servers[1].url, servers[1].accessToken, 'user_1_channel@localhost:9001')
+    })
+  })
+
   describe('Mark as read', function () {
     it('Should mark as read some notifications', async function () {
       const res = await getUserNotifications(servers[ 0 ].url, userAccessToken, 2, 3)
@@ -940,6 +1208,8 @@ describe('Test users notifications', function () {
     })
 
     it('Should not have notifications', async function () {
+      this.timeout(20000)
+
       await updateMyNotificationSettings(servers[0].url, userAccessToken, immutableAssign(allNotificationSettings, {
         newVideoFromSubscription: UserNotificationSettingValue.NONE
       }))
@@ -957,6 +1227,8 @@ describe('Test users notifications', function () {
     })
 
     it('Should only have web notifications', async function () {
+      this.timeout(20000)
+
       await updateMyNotificationSettings(servers[0].url, userAccessToken, immutableAssign(allNotificationSettings, {
         newVideoFromSubscription: UserNotificationSettingValue.WEB
       }))
@@ -981,6 +1253,8 @@ describe('Test users notifications', function () {
     })
 
     it('Should only have mail notifications', async function () {
+      this.timeout(20000)
+
       await updateMyNotificationSettings(servers[0].url, userAccessToken, immutableAssign(allNotificationSettings, {
         newVideoFromSubscription: UserNotificationSettingValue.EMAIL
       }))
@@ -1005,6 +1279,8 @@ describe('Test users notifications', function () {
     })
 
     it('Should have email and web notifications', async function () {
+      this.timeout(20000)
+
       await updateMyNotificationSettings(servers[0].url, userAccessToken, immutableAssign(allNotificationSettings, {
         newVideoFromSubscription: UserNotificationSettingValue.WEB | UserNotificationSettingValue.EMAIL
       }))
@@ -1026,6 +1302,6 @@ describe('Test users notifications', function () {
   after(async function () {
     MockSmtpServer.Instance.kill()
 
-    killallServers(servers)
+    await cleanupTests(servers)
   })
 })
diff --git a/server/tests/api/redundancy/redundancy.ts b/server/tests/api/redundancy/redundancy.ts
index 9d3ce8153..e31329c25 100644
--- a/server/tests/api/redundancy/redundancy.ts
+++ b/server/tests/api/redundancy/redundancy.ts
@@ -4,30 +4,36 @@ import * as chai from 'chai'
 import 'mocha'
 import { VideoDetails } from '../../../../shared/models/videos'
 import {
+  checkSegmentHash,
+  checkVideoFilesWereRemoved, cleanupTests,
   doubleFollow,
   flushAndRunMultipleServers,
   getFollowingListPaginationAndSort,
   getVideo,
+  getVideoWithToken,
   immutableAssign,
-  killallServers, makeGetRequest,
+  killallServers,
+  makeGetRequest,
+  removeVideo,
+  reRunServer,
   root,
   ServerInfo,
-  setAccessTokensToServers, unfollow,
+  setAccessTokensToServers,
+  unfollow,
   uploadVideo,
   viewVideo,
   wait,
-  waitUntilLog,
-  checkVideoFilesWereRemoved, removeVideo, getVideoWithToken
-} from '../../../../shared/utils'
-import { waitJobs } from '../../../../shared/utils/server/jobs'
+  waitUntilLog
+} from '../../../../shared/extra-utils'
+import { waitJobs } from '../../../../shared/extra-utils/server/jobs'
 
 import * as magnetUtil from 'magnet-uri'
-import { updateRedundancy } from '../../../../shared/utils/server/redundancy'
+import { updateRedundancy } from '../../../../shared/extra-utils/server/redundancy'
 import { ActorFollow } from '../../../../shared/models/actors'
 import { readdir } from 'fs-extra'
 import { join } from 'path'
 import { VideoRedundancyStrategy } from '../../../../shared/models/redundancy'
-import { getStats } from '../../../../shared/utils/server/stats'
+import { getStats } from '../../../../shared/extra-utils/server/stats'
 import { ServerStats } from '../../../../shared/models/server/server-stats.model'
 
 const expect = chai.expect
@@ -46,8 +52,13 @@ function checkMagnetWebseeds (file: { magnetUri: string, resolution: { id: numbe
   expect(parsed.urlList).to.have.lengthOf(baseWebseeds.length)
 }
 
-async function runServers (strategy: VideoRedundancyStrategy, additionalParams: any = {}) {
+async function flushAndRunServers (strategy: VideoRedundancyStrategy, additionalParams: any = {}) {
   const config = {
+    transcoding: {
+      hls: {
+        enabled: true
+      }
+    },
     redundancy: {
       videos: {
         check_interval: '5 seconds',
@@ -85,7 +96,7 @@ async function runServers (strategy: VideoRedundancyStrategy, additionalParams:
   await waitJobs(servers)
 }
 
-async function check1WebSeed (strategy: VideoRedundancyStrategy, videoUUID?: string) {
+async function check1WebSeed (videoUUID?: string) {
   if (!videoUUID) videoUUID = video1Server2UUID
 
   const webseeds = [
@@ -93,47 +104,17 @@ async function check1WebSeed (strategy: VideoRedundancyStrategy, videoUUID?: str
   ]
 
   for (const server of servers) {
-    {
-      // With token to avoid issues with video follow constraints
-      const res = await getVideoWithToken(server.url, server.accessToken, videoUUID)
+    // With token to avoid issues with video follow constraints
+    const res = await getVideoWithToken(server.url, server.accessToken, videoUUID)
 
-      const video: VideoDetails = res.body
-      for (const f of video.files) {
-        checkMagnetWebseeds(f, webseeds, server)
-      }
+    const video: VideoDetails = res.body
+    for (const f of video.files) {
+      checkMagnetWebseeds(f, webseeds, server)
     }
   }
 }
 
-async function checkStatsWith2Webseed (strategy: VideoRedundancyStrategy) {
-  const res = await getStats(servers[0].url)
-  const data: ServerStats = res.body
-
-  expect(data.videosRedundancy).to.have.lengthOf(1)
-  const stat = data.videosRedundancy[0]
-
-  expect(stat.strategy).to.equal(strategy)
-  expect(stat.totalSize).to.equal(204800)
-  expect(stat.totalUsed).to.be.at.least(1).and.below(204801)
-  expect(stat.totalVideoFiles).to.equal(4)
-  expect(stat.totalVideos).to.equal(1)
-}
-
-async function checkStatsWith1Webseed (strategy: VideoRedundancyStrategy) {
-  const res = await getStats(servers[0].url)
-  const data: ServerStats = res.body
-
-  expect(data.videosRedundancy).to.have.lengthOf(1)
-
-  const stat = data.videosRedundancy[0]
-  expect(stat.strategy).to.equal(strategy)
-  expect(stat.totalSize).to.equal(204800)
-  expect(stat.totalUsed).to.equal(0)
-  expect(stat.totalVideoFiles).to.equal(0)
-  expect(stat.totalVideos).to.equal(0)
-}
-
-async function check2Webseeds (strategy: VideoRedundancyStrategy, videoUUID?: string) {
+async function check2Webseeds (videoUUID?: string) {
   if (!videoUUID) videoUUID = video1Server2UUID
 
   const webseeds = [
@@ -158,7 +139,7 @@ async function check2Webseeds (strategy: VideoRedundancyStrategy, videoUUID?: st
       await makeGetRequest({
         url: servers[1].url,
         statusCodeExpected: 200,
-        path: '/static/webseed/' + `${videoUUID}-${file.resolution.id}.mp4`,
+        path: `/static/webseed/${videoUUID}-${file.resolution.id}.mp4`,
         contentType: null
       })
     }
@@ -174,6 +155,85 @@ async function check2Webseeds (strategy: VideoRedundancyStrategy, videoUUID?: st
   }
 }
 
+async function check0PlaylistRedundancies (videoUUID?: string) {
+  if (!videoUUID) videoUUID = video1Server2UUID
+
+  for (const server of servers) {
+    // With token to avoid issues with video follow constraints
+    const res = await getVideoWithToken(server.url, server.accessToken, videoUUID)
+    const video: VideoDetails = res.body
+
+    expect(video.streamingPlaylists).to.be.an('array')
+    expect(video.streamingPlaylists).to.have.lengthOf(1)
+    expect(video.streamingPlaylists[0].redundancies).to.have.lengthOf(0)
+  }
+}
+
+async function check1PlaylistRedundancies (videoUUID?: string) {
+  if (!videoUUID) videoUUID = video1Server2UUID
+
+  for (const server of servers) {
+    const res = await getVideo(server.url, videoUUID)
+    const video: VideoDetails = res.body
+
+    expect(video.streamingPlaylists).to.have.lengthOf(1)
+    expect(video.streamingPlaylists[0].redundancies).to.have.lengthOf(1)
+
+    const redundancy = video.streamingPlaylists[0].redundancies[0]
+
+    expect(redundancy.baseUrl).to.equal(servers[0].url + '/static/redundancy/hls/' + videoUUID)
+  }
+
+  const baseUrlPlaylist = servers[1].url + '/static/streaming-playlists/hls'
+  const baseUrlSegment = servers[0].url + '/static/redundancy/hls'
+
+  const res = await getVideo(servers[0].url, videoUUID)
+  const hlsPlaylist = (res.body as VideoDetails).streamingPlaylists[0]
+
+  for (const resolution of [ 240, 360, 480, 720 ]) {
+    await checkSegmentHash(baseUrlPlaylist, baseUrlSegment, videoUUID, resolution, hlsPlaylist)
+  }
+
+  for (const directory of [ 'test1/redundancy/hls', 'test2/streaming-playlists/hls' ]) {
+    const files = await readdir(join(root(), directory, videoUUID))
+    expect(files).to.have.length.at.least(4)
+
+    for (const resolution of [ 240, 360, 480, 720 ]) {
+      const filename = `${videoUUID}-${resolution}-fragmented.mp4`
+
+      expect(files.find(f => f === filename)).to.not.be.undefined
+    }
+  }
+}
+
+async function checkStatsWith2Webseed (strategy: VideoRedundancyStrategy) {
+  const res = await getStats(servers[0].url)
+  const data: ServerStats = res.body
+
+  expect(data.videosRedundancy).to.have.lengthOf(1)
+  const stat = data.videosRedundancy[0]
+
+  expect(stat.strategy).to.equal(strategy)
+  expect(stat.totalSize).to.equal(204800)
+  expect(stat.totalUsed).to.be.at.least(1).and.below(204801)
+  expect(stat.totalVideoFiles).to.equal(4)
+  expect(stat.totalVideos).to.equal(1)
+}
+
+async function checkStatsWith1Webseed (strategy: VideoRedundancyStrategy) {
+  const res = await getStats(servers[0].url)
+  const data: ServerStats = res.body
+
+  expect(data.videosRedundancy).to.have.lengthOf(1)
+
+  const stat = data.videosRedundancy[0]
+  expect(stat.strategy).to.equal(strategy)
+  expect(stat.totalSize).to.equal(204800)
+  expect(stat.totalUsed).to.equal(0)
+  expect(stat.totalVideoFiles).to.equal(0)
+  expect(stat.totalVideos).to.equal(0)
+}
+
 async function enableRedundancyOnServer1 () {
   await updateRedundancy(servers[ 0 ].url, servers[ 0 ].accessToken, servers[ 1 ].host, true)
 
@@ -204,10 +264,6 @@ async function disableRedundancyOnServer1 () {
   expect(server2.following.hostRedundancyAllowed).to.be.false
 }
 
-async function cleanServers () {
-  killallServers(servers)
-}
-
 describe('Test videos redundancy', function () {
 
   describe('With most-views strategy', function () {
@@ -216,11 +272,12 @@ describe('Test videos redundancy', function () {
     before(function () {
       this.timeout(120000)
 
-      return runServers(strategy)
+      return flushAndRunServers(strategy)
     })
 
     it('Should have 1 webseed on the first video', async function () {
-      await check1WebSeed(strategy)
+      await check1WebSeed()
+      await check0PlaylistRedundancies()
       await checkStatsWith1Webseed(strategy)
     })
 
@@ -229,31 +286,33 @@ describe('Test videos redundancy', function () {
     })
 
     it('Should have 2 webseeds on the first video', async function () {
-      this.timeout(40000)
+      this.timeout(80000)
 
       await waitJobs(servers)
-      await waitUntilLog(servers[0], 'Duplicated ', 4)
+      await waitUntilLog(servers[0], 'Duplicated ', 5)
       await waitJobs(servers)
 
-      await check2Webseeds(strategy)
+      await check2Webseeds()
+      await check1PlaylistRedundancies()
       await checkStatsWith2Webseed(strategy)
     })
 
     it('Should undo redundancy on server 1 and remove duplicated videos', async function () {
-      this.timeout(40000)
+      this.timeout(80000)
 
       await disableRedundancyOnServer1()
 
       await waitJobs(servers)
       await wait(5000)
 
-      await check1WebSeed(strategy)
+      await check1WebSeed()
+      await check0PlaylistRedundancies()
 
-      await checkVideoFilesWereRemoved(video1Server2UUID, servers[0].serverNumber, [ 'videos' ])
+      await checkVideoFilesWereRemoved(video1Server2UUID, servers[0].serverNumber, [ 'videos', join('playlists', 'hls') ])
     })
 
-    after(function () {
-      return cleanServers()
+    after(async function () {
+      return cleanupTests(servers)
     })
   })
 
@@ -263,11 +322,12 @@ describe('Test videos redundancy', function () {
     before(function () {
       this.timeout(120000)
 
-      return runServers(strategy)
+      return flushAndRunServers(strategy)
     })
 
     it('Should have 1 webseed on the first video', async function () {
-      await check1WebSeed(strategy)
+      await check1WebSeed()
+      await check0PlaylistRedundancies()
       await checkStatsWith1Webseed(strategy)
     })
 
@@ -276,31 +336,33 @@ describe('Test videos redundancy', function () {
     })
 
     it('Should have 2 webseeds on the first video', async function () {
-      this.timeout(40000)
+      this.timeout(80000)
 
       await waitJobs(servers)
-      await waitUntilLog(servers[0], 'Duplicated ', 4)
+      await waitUntilLog(servers[0], 'Duplicated ', 5)
       await waitJobs(servers)
 
-      await check2Webseeds(strategy)
+      await check2Webseeds()
+      await check1PlaylistRedundancies()
       await checkStatsWith2Webseed(strategy)
     })
 
     it('Should unfollow on server 1 and remove duplicated videos', async function () {
-      this.timeout(40000)
+      this.timeout(80000)
 
       await unfollow(servers[0].url, servers[0].accessToken, servers[1])
 
       await waitJobs(servers)
       await wait(5000)
 
-      await check1WebSeed(strategy)
+      await check1WebSeed()
+      await check0PlaylistRedundancies()
 
       await checkVideoFilesWereRemoved(video1Server2UUID, servers[0].serverNumber, [ 'videos' ])
     })
 
-    after(function () {
-      return cleanServers()
+    after(async function () {
+      await cleanupTests(servers)
     })
   })
 
@@ -310,11 +372,12 @@ describe('Test videos redundancy', function () {
     before(function () {
       this.timeout(120000)
 
-      return runServers(strategy, { min_views: 3 })
+      return flushAndRunServers(strategy, { min_views: 3 })
     })
 
     it('Should have 1 webseed on the first video', async function () {
-      await check1WebSeed(strategy)
+      await check1WebSeed()
+      await check0PlaylistRedundancies()
       await checkStatsWith1Webseed(strategy)
     })
 
@@ -323,18 +386,19 @@ describe('Test videos redundancy', function () {
     })
 
     it('Should still have 1 webseed on the first video', async function () {
-      this.timeout(40000)
+      this.timeout(80000)
 
       await waitJobs(servers)
       await wait(15000)
       await waitJobs(servers)
 
-      await check1WebSeed(strategy)
+      await check1WebSeed()
+      await check0PlaylistRedundancies()
       await checkStatsWith1Webseed(strategy)
     })
 
     it('Should view 2 times the first video to have > min_views config', async function () {
-      this.timeout(40000)
+      this.timeout(80000)
 
       await viewVideo(servers[ 0 ].url, video1Server2UUID)
       await viewVideo(servers[ 2 ].url, video1Server2UUID)
@@ -344,13 +408,14 @@ describe('Test videos redundancy', function () {
     })
 
     it('Should have 2 webseeds on the first video', async function () {
-      this.timeout(40000)
+      this.timeout(80000)
 
       await waitJobs(servers)
-      await waitUntilLog(servers[0], 'Duplicated ', 4)
+      await waitUntilLog(servers[0], 'Duplicated ', 5)
       await waitJobs(servers)
 
-      await check2Webseeds(strategy)
+      await check2Webseeds()
+      await check1PlaylistRedundancies()
       await checkStatsWith2Webseed(strategy)
     })
 
@@ -366,8 +431,8 @@ describe('Test videos redundancy', function () {
       }
     })
 
-    after(function () {
-      return cleanServers()
+    after(async function () {
+      await cleanupTests(servers)
     })
   })
 
@@ -399,13 +464,13 @@ describe('Test videos redundancy', function () {
     before(async function () {
       this.timeout(120000)
 
-      await runServers(strategy, { min_lifetime: '7 seconds', min_views: 0 })
+      await flushAndRunServers(strategy, { min_lifetime: '7 seconds', min_views: 0 })
 
       await enableRedundancyOnServer1()
     })
 
     it('Should still have 2 webseeds after 10 seconds', async function () {
-      this.timeout(40000)
+      this.timeout(80000)
 
       await wait(10000)
 
@@ -420,7 +485,7 @@ describe('Test videos redundancy', function () {
     })
 
     it('Should stop server 1 and expire video redundancy', async function () {
-      this.timeout(40000)
+      this.timeout(80000)
 
       killallServers([ servers[0] ])
 
@@ -429,8 +494,8 @@ describe('Test videos redundancy', function () {
       await checkNotContains([ servers[1], servers[2] ], 'http%3A%2F%2Flocalhost%3A9001')
     })
 
-    after(function () {
-      return killallServers([ servers[1], servers[2] ])
+    after(async function () {
+      await cleanupTests(servers)
     })
   })
 
@@ -441,15 +506,16 @@ describe('Test videos redundancy', function () {
     before(async function () {
       this.timeout(120000)
 
-      await runServers(strategy, { min_lifetime: '7 seconds', min_views: 0 })
+      await flushAndRunServers(strategy, { min_lifetime: '7 seconds', min_views: 0 })
 
       await enableRedundancyOnServer1()
 
       await waitJobs(servers)
-      await waitUntilLog(servers[0], 'Duplicated ', 4)
+      await waitUntilLog(servers[0], 'Duplicated ', 5)
       await waitJobs(servers)
 
-      await check2Webseeds(strategy)
+      await check2Webseeds()
+      await check1PlaylistRedundancies()
       await checkStatsWith2Webseed(strategy)
 
       const res = await uploadVideo(servers[ 1 ].url, servers[ 1 ].accessToken, { name: 'video 2 server 2' })
@@ -467,8 +533,10 @@ describe('Test videos redundancy', function () {
         await wait(1000)
 
         try {
-          await check1WebSeed(strategy, video1Server2UUID)
-          await check2Webseeds(strategy, video2Server2UUID)
+          await check1WebSeed(video1Server2UUID)
+          await check0PlaylistRedundancies(video1Server2UUID)
+          await check2Webseeds(video2Server2UUID)
+          await check1PlaylistRedundancies(video2Server2UUID)
 
           checked = true
         } catch {
@@ -477,8 +545,28 @@ describe('Test videos redundancy', function () {
       }
     })
 
-    after(function () {
-      return cleanServers()
+    it('Should disable strategy and remove redundancies', async function () {
+      this.timeout(80000)
+
+      await waitJobs(servers)
+
+      killallServers([ servers[ 0 ] ])
+      await reRunServer(servers[ 0 ], {
+        redundancy: {
+          videos: {
+            check_interval: '1 second',
+            strategies: []
+          }
+        }
+      })
+
+      await waitJobs(servers)
+
+      await checkVideoFilesWereRemoved(video1Server2UUID, servers[0].serverNumber, [ join('redundancy', 'hls') ])
+    })
+
+    after(async function () {
+      await cleanupTests(servers)
     })
   })
 })
diff --git a/server/tests/api/search/search-activitypub-video-channels.ts b/server/tests/api/search/search-activitypub-video-channels.ts
index a411e973b..4d1ceb767 100644
--- a/server/tests/api/search/search-activitypub-video-channels.ts
+++ b/server/tests/api/search/search-activitypub-video-channels.ts
@@ -3,7 +3,7 @@
 import * as chai from 'chai'
 import 'mocha'
 import {
-  addVideoChannel,
+  addVideoChannel, cleanupTests,
   createUser,
   deleteVideoChannel,
   flushAndRunMultipleServers,
@@ -17,10 +17,10 @@ import {
   uploadVideo,
   userLogin,
   wait
-} from '../../../../shared/utils'
-import { waitJobs } from '../../../../shared/utils/server/jobs'
+} from '../../../../shared/extra-utils'
+import { waitJobs } from '../../../../shared/extra-utils/server/jobs'
 import { VideoChannel } from '../../../../shared/models/videos'
-import { searchVideoChannel } from '../../../../shared/utils/search/video-channels'
+import { searchVideoChannel } from '../../../../shared/extra-utils/search/video-channels'
 
 const expect = chai.expect
 
@@ -33,14 +33,12 @@ describe('Test a ActivityPub video channels search', function () {
   before(async function () {
     this.timeout(120000)
 
-    await flushTests()
-
     servers = await flushAndRunMultipleServers(2)
 
     await setAccessTokensToServers(servers)
 
     {
-      await createUser(servers[0].url, servers[0].accessToken, 'user1_server1', 'password')
+      await createUser({ url: servers[ 0 ].url, accessToken: servers[ 0 ].accessToken, username: 'user1_server1', password: 'password' })
       const channel = {
         name: 'channel1_server1',
         displayName: 'Channel 1 server 1'
@@ -50,7 +48,7 @@ describe('Test a ActivityPub video channels search', function () {
 
     {
       const user = { username: 'user1_server2', password: 'password' }
-      await createUser(servers[1].url, servers[1].accessToken, user.username, user.password)
+      await createUser({ url: servers[ 1 ].url, accessToken: servers[ 1 ].accessToken, username: user.username, password: user.password })
       userServer2Token = await userLogin(servers[1], user)
 
       const channel = {
@@ -208,11 +206,6 @@ describe('Test a ActivityPub video channels search', function () {
   })
 
   after(async function () {
-    killallServers(servers)
-
-    // Keep the logs if the test failed
-    if (this['ok']) {
-      await flushTests()
-    }
+    await cleanupTests(servers)
   })
 })
diff --git a/server/tests/api/search/search-activitypub-videos.ts b/server/tests/api/search/search-activitypub-videos.ts
index f881917e7..e039961cb 100644
--- a/server/tests/api/search/search-activitypub-videos.ts
+++ b/server/tests/api/search/search-activitypub-videos.ts
@@ -15,9 +15,9 @@ import {
   updateVideo,
   uploadVideo,
   wait,
-  searchVideo
-} from '../../../../shared/utils'
-import { waitJobs } from '../../../../shared/utils/server/jobs'
+  searchVideo, cleanupTests
+} from '../../../../shared/extra-utils'
+import { waitJobs } from '../../../../shared/extra-utils/server/jobs'
 import { Video, VideoPrivacy } from '../../../../shared/models/videos'
 
 const expect = chai.expect
@@ -30,8 +30,6 @@ describe('Test a ActivityPub videos search', function () {
   before(async function () {
     this.timeout(120000)
 
-    await flushTests()
-
     servers = await flushAndRunMultipleServers(2)
 
     await setAccessTokensToServers(servers)
@@ -152,11 +150,6 @@ describe('Test a ActivityPub videos search', function () {
   })
 
   after(async function () {
-    killallServers(servers)
-
-    // Keep the logs if the test failed
-    if (this['ok']) {
-      await flushTests()
-    }
+    await cleanupTests(servers)
   })
 })
diff --git a/server/tests/api/search/search-videos.ts b/server/tests/api/search/search-videos.ts
index 50da837da..1a086b33a 100644
--- a/server/tests/api/search/search-videos.ts
+++ b/server/tests/api/search/search-videos.ts
@@ -6,14 +6,15 @@ import {
   advancedVideosSearch,
   flushTests,
   killallServers,
-  runServer,
+  flushAndRunServer,
   searchVideo,
   ServerInfo,
   setAccessTokensToServers,
   uploadVideo,
   wait,
-  immutableAssign
-} from '../../../../shared/utils'
+  immutableAssign,
+  cleanupTests
+} from '../../../../shared/extra-utils'
 
 const expect = chai.expect
 
@@ -24,9 +25,7 @@ describe('Test a videos search', function () {
   before(async function () {
     this.timeout(30000)
 
-    await flushTests()
-
-    server = await runServer(1)
+    server = await flushAndRunServer(1)
 
     await setAccessTokensToServers([ server ])
 
@@ -60,7 +59,10 @@ describe('Test a videos search', function () {
       const attributes6 = immutableAssign(attributes1, { name: attributes1.name + ' - 6', tags: [ 't1', 't2 '] })
       await uploadVideo(server.url, server.accessToken, attributes6)
 
-      const attributes7 = immutableAssign(attributes1, { name: attributes1.name + ' - 7' })
+      const attributes7 = immutableAssign(attributes1, {
+        name: attributes1.name + ' - 7',
+        originallyPublishedAt: '2019-02-12T09:58:08.286Z'
+      })
       await uploadVideo(server.url, server.accessToken, attributes7)
 
       const attributes8 = immutableAssign(attributes1, { name: attributes1.name + ' - 8', licence: 4 })
@@ -343,12 +345,68 @@ describe('Test a videos search', function () {
     expect(videos[0].name).to.equal('1111 2222 3333')
   })
 
-  after(async function () {
-    killallServers([ server ])
+  it('Should search on originally published date', async function () {
+    const baseQuery = {
+      search: '1111 2222 3333',
+      languageOneOf: [ 'pl', 'fr' ],
+      durationMax: 4,
+      nsfw: 'false' as 'false',
+      licenceOneOf: [ 1, 4 ]
+    }
+
+    {
+      const query = immutableAssign(baseQuery, { originallyPublishedStartDate: '2019-02-11T09:58:08.286Z' })
+      const res = await advancedVideosSearch(server.url, query)
+
+      expect(res.body.total).to.equal(1)
+      expect(res.body.data[0].name).to.equal('1111 2222 3333 - 7')
+    }
+
+    {
+      const query = immutableAssign(baseQuery, { originallyPublishedEndDate: '2019-03-11T09:58:08.286Z' })
+      const res = await advancedVideosSearch(server.url, query)
+
+      expect(res.body.total).to.equal(1)
+      expect(res.body.data[0].name).to.equal('1111 2222 3333 - 7')
+    }
 
-    // Keep the logs if the test failed
-    if (this['ok']) {
-      await flushTests()
+    {
+      const query = immutableAssign(baseQuery, { originallyPublishedEndDate: '2019-01-11T09:58:08.286Z' })
+      const res = await advancedVideosSearch(server.url, query)
+
+      expect(res.body.total).to.equal(0)
+    }
+
+    {
+      const query = immutableAssign(baseQuery, { originallyPublishedStartDate: '2019-03-11T09:58:08.286Z' })
+      const res = await advancedVideosSearch(server.url, query)
+
+      expect(res.body.total).to.equal(0)
+    }
+
+    {
+      const query = immutableAssign(baseQuery, {
+        originallyPublishedStartDate: '2019-01-11T09:58:08.286Z',
+        originallyPublishedEndDate: '2019-01-10T09:58:08.286Z'
+      })
+      const res = await advancedVideosSearch(server.url, query)
+
+      expect(res.body.total).to.equal(0)
+    }
+
+    {
+      const query = immutableAssign(baseQuery, {
+        originallyPublishedStartDate: '2019-01-11T09:58:08.286Z',
+        originallyPublishedEndDate: '2019-04-11T09:58:08.286Z'
+      })
+      const res = await advancedVideosSearch(server.url, query)
+
+      expect(res.body.total).to.equal(1)
+      expect(res.body.data[0].name).to.equal('1111 2222 3333 - 7')
     }
   })
+
+  after(async function () {
+    await cleanupTests([ server ])
+  })
 })
diff --git a/server/tests/api/server/config.ts b/server/tests/api/server/config.ts
index bebfc7398..c0d11914b 100644
--- a/server/tests/api/server/config.ts
+++ b/server/tests/api/server/config.ts
@@ -5,18 +5,18 @@ import * as chai from 'chai'
 import { About } from '../../../../shared/models/server/about.model'
 import { CustomConfig } from '../../../../shared/models/server/custom-config.model'
 import {
+  cleanupTests,
   deleteCustomConfig,
+  flushAndRunServer,
   getAbout,
-  killallServers,
-  reRunServer,
-  flushTests,
   getConfig,
   getCustomConfig,
+  killallServers,
   registerUser,
-  runServer,
+  reRunServer,
   setAccessTokensToServers,
   updateCustomConfig
-} from '../../../../shared/utils'
+} from '../../../../shared/extra-utils'
 import { ServerConfig } from '../../../../shared/models'
 
 const expect = chai.expect
@@ -30,6 +30,7 @@ function checkInitialConfig (data: CustomConfig) {
   expect(data.instance.description).to.equal('Welcome to this PeerTube instance!')
   expect(data.instance.terms).to.equal('No terms for now.')
   expect(data.instance.defaultClientRoute).to.equal('/videos/trending')
+  expect(data.instance.isNSFW).to.be.false
   expect(data.instance.defaultNSFWPolicy).to.equal('display')
   expect(data.instance.customizations.css).to.be.empty
   expect(data.instance.customizations.javascript).to.be.empty
@@ -57,8 +58,14 @@ function checkInitialConfig (data: CustomConfig) {
   expect(data.transcoding.resolutions['480p']).to.be.true
   expect(data.transcoding.resolutions['720p']).to.be.true
   expect(data.transcoding.resolutions['1080p']).to.be.true
+  expect(data.transcoding.hls.enabled).to.be.true
+
   expect(data.import.videos.http.enabled).to.be.true
   expect(data.import.videos.torrent.enabled).to.be.true
+  expect(data.autoBlacklist.videos.ofUsers.enabled).to.be.false
+
+  expect(data.followers.instance.enabled).to.be.true
+  expect(data.followers.instance.manualApproval).to.be.false
 }
 
 function checkUpdatedConfig (data: CustomConfig) {
@@ -67,6 +74,7 @@ function checkUpdatedConfig (data: CustomConfig) {
   expect(data.instance.description).to.equal('my super description')
   expect(data.instance.terms).to.equal('my super terms')
   expect(data.instance.defaultClientRoute).to.equal('/videos/recently-added')
+  expect(data.instance.isNSFW).to.be.true
   expect(data.instance.defaultNSFWPolicy).to.equal('blur')
   expect(data.instance.customizations.javascript).to.equal('alert("coucou")')
   expect(data.instance.customizations.css).to.equal('body { background-color: red; }')
@@ -79,7 +87,7 @@ function checkUpdatedConfig (data: CustomConfig) {
 
   expect(data.signup.enabled).to.be.false
   expect(data.signup.limit).to.equal(5)
-  expect(data.signup.requiresEmailVerification).to.be.true
+  expect(data.signup.requiresEmailVerification).to.be.false
 
   expect(data.admin.email).to.equal('superadmin1@example.com')
   expect(data.contactForm.enabled).to.be.false
@@ -95,9 +103,14 @@ function checkUpdatedConfig (data: CustomConfig) {
   expect(data.transcoding.resolutions['480p']).to.be.true
   expect(data.transcoding.resolutions['720p']).to.be.false
   expect(data.transcoding.resolutions['1080p']).to.be.false
+  expect(data.transcoding.hls.enabled).to.be.false
 
   expect(data.import.videos.http.enabled).to.be.false
   expect(data.import.videos.torrent.enabled).to.be.false
+  expect(data.autoBlacklist.videos.ofUsers.enabled).to.be.true
+
+  expect(data.followers.instance.enabled).to.be.false
+  expect(data.followers.instance.manualApproval).to.be.true
 }
 
 describe('Test config', function () {
@@ -105,9 +118,7 @@ describe('Test config', function () {
 
   before(async function () {
     this.timeout(30000)
-
-    await flushTests()
-    server = await runServer(1)
+    server = await flushAndRunServer(1)
     await setAccessTokensToServers([ server ])
   })
 
@@ -160,6 +171,7 @@ describe('Test config', function () {
         description: 'my super description',
         terms: 'my super terms',
         defaultClientRoute: '/videos/recently-added',
+        isNSFW: true,
         defaultNSFWPolicy: 'blur' as 'blur',
         customizations: {
           javascript: 'alert("coucou")',
@@ -183,7 +195,7 @@ describe('Test config', function () {
       signup: {
         enabled: false,
         limit: 5,
-        requiresEmailVerification: true
+        requiresEmailVerification: false
       },
       admin: {
         email: 'superadmin1@example.com'
@@ -205,6 +217,9 @@ describe('Test config', function () {
           '480p': true,
           '720p': false,
           '1080p': false
+        },
+        hls: {
+          enabled: false
         }
       },
       import: {
@@ -216,6 +231,19 @@ describe('Test config', function () {
             enabled: false
           }
         }
+      },
+      autoBlacklist: {
+        videos: {
+          ofUsers: {
+            enabled: true
+          }
+        }
+      },
+      followers: {
+        instance: {
+          enabled: false,
+          manualApproval: true
+        }
       }
     }
     await updateCustomConfig(server.url, server.accessToken, newCustomConfig)
@@ -273,6 +301,6 @@ describe('Test config', function () {
   })
 
   after(async function () {
-    killallServers([ server ])
+    await cleanupTests([ server ])
   })
 })
diff --git a/server/tests/api/server/contact-form.ts b/server/tests/api/server/contact-form.ts
index 06a2f89b0..ba51198b3 100644
--- a/server/tests/api/server/contact-form.ts
+++ b/server/tests/api/server/contact-form.ts
@@ -2,10 +2,18 @@
 
 import * as chai from 'chai'
 import 'mocha'
-import { flushTests, killallServers, runServer, ServerInfo, setAccessTokensToServers, wait } from '../../../../shared/utils'
-import { MockSmtpServer } from '../../../../shared/utils/miscs/email'
-import { waitJobs } from '../../../../shared/utils/server/jobs'
-import { sendContactForm } from '../../../../shared/utils/server/contact-form'
+import {
+  flushTests,
+  killallServers,
+  flushAndRunServer,
+  ServerInfo,
+  setAccessTokensToServers,
+  wait,
+  cleanupTests
+} from '../../../../shared/extra-utils'
+import { MockSmtpServer } from '../../../../shared/extra-utils/miscs/email'
+import { waitJobs } from '../../../../shared/extra-utils/server/jobs'
+import { sendContactForm } from '../../../../shared/extra-utils/server/contact-form'
 
 const expect = chai.expect
 
@@ -18,14 +26,12 @@ describe('Test contact form', function () {
 
     await MockSmtpServer.Instance.collectEmails(emails)
 
-    await flushTests()
-
     const overrideConfig = {
       smtp: {
         hostname: 'localhost'
       }
     }
-    server = await runServer(1, overrideConfig)
+    server = await flushAndRunServer(1, overrideConfig)
     await setAccessTokensToServers([ server ])
   })
 
@@ -82,6 +88,7 @@ describe('Test contact form', function () {
 
   after(async function () {
     MockSmtpServer.Instance.kill()
-    killallServers([ server ])
+
+    await cleanupTests([ server ])
   })
 })
diff --git a/server/tests/api/server/email.ts b/server/tests/api/server/email.ts
index f8f16f54f..bacdf1b1b 100644
--- a/server/tests/api/server/email.ts
+++ b/server/tests/api/server/email.ts
@@ -10,7 +10,7 @@ import {
   createUser, removeVideoFromBlacklist,
   reportVideoAbuse,
   resetPassword,
-  runServer,
+  flushAndRunServer,
   unblockUser,
   uploadVideo,
   userLogin,
@@ -18,10 +18,10 @@ import {
   flushTests,
   killallServers,
   ServerInfo,
-  setAccessTokensToServers
-} from '../../../../shared/utils'
-import { MockSmtpServer } from '../../../../shared/utils/miscs/email'
-import { waitJobs } from '../../../../shared/utils/server/jobs'
+  setAccessTokensToServers, cleanupTests
+} from '../../../../shared/extra-utils'
+import { MockSmtpServer } from '../../../../shared/extra-utils/miscs/email'
+import { waitJobs } from '../../../../shared/extra-utils/server/jobs'
 
 const expect = chai.expect
 
@@ -43,18 +43,16 @@ describe('Test emails', function () {
 
     await MockSmtpServer.Instance.collectEmails(emails)
 
-    await flushTests()
-
     const overrideConfig = {
       smtp: {
         hostname: 'localhost'
       }
     }
-    server = await runServer(1, overrideConfig)
+    server = await flushAndRunServer(1, overrideConfig)
     await setAccessTokensToServers([ server ])
 
     {
-      const res = await createUser(server.url, server.accessToken, user.username, user.password)
+      const res = await createUser({ url: server.url, accessToken: server.accessToken, username: user.username, password: user.password })
       userId = res.body.user.id
 
       userAccessToken = await userLogin(server, user)
@@ -142,7 +140,8 @@ describe('Test emails', function () {
     })
   })
 
-  describe('When blocking/unblocking user', async function () {
+  describe('When blocking/unblocking user', function () {
+
     it('Should send the notification email when blocking a user', async function () {
       this.timeout(10000)
 
@@ -259,6 +258,7 @@ describe('Test emails', function () {
 
   after(async function () {
     MockSmtpServer.Instance.kill()
-    killallServers([ server ])
+
+    await cleanupTests([ server ])
   })
 })
diff --git a/server/tests/api/server/follow-constraints.ts b/server/tests/api/server/follow-constraints.ts
index 8bb073c41..4285a9e7a 100644
--- a/server/tests/api/server/follow-constraints.ts
+++ b/server/tests/api/server/follow-constraints.ts
@@ -12,11 +12,11 @@ import {
   killallServers,
   ServerInfo,
   setAccessTokensToServers,
-  uploadVideo
-} from '../../../../shared/utils'
-import { unfollow } from '../../../../shared/utils/server/follows'
-import { userLogin } from '../../../../shared/utils/users/login'
-import { createUser } from '../../../../shared/utils/users/users'
+  uploadVideo, cleanupTests
+} from '../../../../shared/extra-utils'
+import { unfollow } from '../../../../shared/extra-utils/server/follows'
+import { userLogin } from '../../../../shared/extra-utils/users/login'
+import { createUser } from '../../../../shared/extra-utils/users/users'
 
 const expect = chai.expect
 
@@ -47,7 +47,7 @@ describe('Test follow constraints', function () {
       username: 'user1',
       password: 'super_password'
     }
-    await createUser(servers[0].url, servers[0].accessToken, user.username, user.password)
+    await createUser({ url: servers[ 0 ].url, accessToken: servers[ 0 ].accessToken, username: user.username, password: user.password })
     userAccessToken = await userLogin(servers[0], user)
 
     await doubleFollow(servers[0], servers[1])
@@ -220,6 +220,6 @@ describe('Test follow constraints', function () {
   })
 
   after(async function () {
-    killallServers(servers)
+    await cleanupTests(servers)
   })
 })
diff --git a/server/tests/api/server/follows-moderation.ts b/server/tests/api/server/follows-moderation.ts
new file mode 100644
index 000000000..2a3a4d5c8
--- /dev/null
+++ b/server/tests/api/server/follows-moderation.ts
@@ -0,0 +1,195 @@
+/* tslint:disable:no-unused-expression */
+
+import * as chai from 'chai'
+import 'mocha'
+import {
+  acceptFollower, cleanupTests,
+  flushAndRunMultipleServers,
+  killallServers,
+  ServerInfo,
+  setAccessTokensToServers,
+  updateCustomSubConfig
+} from '../../../../shared/extra-utils/index'
+import {
+  follow,
+  getFollowersListPaginationAndSort,
+  getFollowingListPaginationAndSort,
+  removeFollower,
+  rejectFollower
+} from '../../../../shared/extra-utils/server/follows'
+import { waitJobs } from '../../../../shared/extra-utils/server/jobs'
+import { ActorFollow } from '../../../../shared/models/actors'
+
+const expect = chai.expect
+
+async function checkServer1And2HasFollowers (servers: ServerInfo[], state = 'accepted') {
+  {
+    const res = await getFollowingListPaginationAndSort(servers[0].url, 0, 5, 'createdAt')
+    expect(res.body.total).to.equal(1)
+
+    const follow = res.body.data[0] as ActorFollow
+    expect(follow.state).to.equal(state)
+    expect(follow.follower.url).to.equal('http://localhost:9001/accounts/peertube')
+    expect(follow.following.url).to.equal('http://localhost:9002/accounts/peertube')
+  }
+
+  {
+    const res = await getFollowersListPaginationAndSort(servers[1].url, 0, 5, 'createdAt')
+    expect(res.body.total).to.equal(1)
+
+    const follow = res.body.data[0] as ActorFollow
+    expect(follow.state).to.equal(state)
+    expect(follow.follower.url).to.equal('http://localhost:9001/accounts/peertube')
+    expect(follow.following.url).to.equal('http://localhost:9002/accounts/peertube')
+  }
+}
+
+async function checkNoFollowers (servers: ServerInfo[]) {
+  {
+    const res = await getFollowingListPaginationAndSort(servers[ 0 ].url, 0, 5, 'createdAt')
+    expect(res.body.total).to.equal(0)
+  }
+
+  {
+    const res = await getFollowersListPaginationAndSort(servers[ 1 ].url, 0, 5, 'createdAt')
+    expect(res.body.total).to.equal(0)
+  }
+}
+
+describe('Test follows moderation', function () {
+  let servers: ServerInfo[] = []
+
+  before(async function () {
+    this.timeout(30000)
+
+    servers = await flushAndRunMultipleServers(3)
+
+    // Get the access tokens
+    await setAccessTokensToServers(servers)
+  })
+
+  it('Should have server 1 following server 2', async function () {
+    this.timeout(30000)
+
+    await follow(servers[0].url, [ servers[1].url ], servers[0].accessToken)
+
+    await waitJobs(servers)
+  })
+
+  it('Should have correct follows', async function () {
+    await checkServer1And2HasFollowers(servers)
+  })
+
+  it('Should remove follower on server 2', async function () {
+    await removeFollower(servers[1].url, servers[1].accessToken, servers[0])
+
+    await waitJobs(servers)
+  })
+
+  it('Should not not have follows anymore', async function () {
+    await checkNoFollowers(servers)
+  })
+
+  it('Should disable followers on server 2', async function () {
+    const subConfig = {
+      followers: {
+        instance: {
+          enabled: false,
+          manualApproval: false
+        }
+      }
+    }
+
+    await updateCustomSubConfig(servers[1].url, servers[1].accessToken, subConfig)
+
+    await follow(servers[0].url, [ servers[1].url ], servers[0].accessToken)
+    await waitJobs(servers)
+
+    await checkNoFollowers(servers)
+  })
+
+  it('Should re enable followers on server 2', async function () {
+    const subConfig = {
+      followers: {
+        instance: {
+          enabled: true,
+          manualApproval: false
+        }
+      }
+    }
+
+    await updateCustomSubConfig(servers[1].url, servers[1].accessToken, subConfig)
+
+    await follow(servers[0].url, [ servers[1].url ], servers[0].accessToken)
+    await waitJobs(servers)
+
+    await checkServer1And2HasFollowers(servers)
+  })
+
+  it('Should manually approve followers', async function () {
+    this.timeout(20000)
+
+    await removeFollower(servers[1].url, servers[1].accessToken, servers[0])
+    await waitJobs(servers)
+
+    const subConfig = {
+      followers: {
+        instance: {
+          enabled: true,
+          manualApproval: true
+        }
+      }
+    }
+
+    await updateCustomSubConfig(servers[1].url, servers[1].accessToken, subConfig)
+    await updateCustomSubConfig(servers[2].url, servers[2].accessToken, subConfig)
+
+    await follow(servers[0].url, [ servers[1].url ], servers[0].accessToken)
+    await waitJobs(servers)
+
+    await checkServer1And2HasFollowers(servers, 'pending')
+  })
+
+  it('Should accept a follower', async function () {
+    await acceptFollower(servers[1].url, servers[1].accessToken, 'peertube@localhost:9001')
+    await waitJobs(servers)
+
+    await checkServer1And2HasFollowers(servers)
+  })
+
+  it('Should reject another follower', async function () {
+    this.timeout(20000)
+
+    await follow(servers[0].url, [ servers[2].url ], servers[0].accessToken)
+    await waitJobs(servers)
+
+    {
+      const res = await getFollowingListPaginationAndSort(servers[0].url, 0, 5, 'createdAt')
+      expect(res.body.total).to.equal(2)
+    }
+
+    {
+      const res = await getFollowersListPaginationAndSort(servers[1].url, 0, 5, 'createdAt')
+      expect(res.body.total).to.equal(1)
+    }
+
+    {
+      const res = await getFollowersListPaginationAndSort(servers[2].url, 0, 5, 'createdAt')
+      expect(res.body.total).to.equal(1)
+    }
+
+    await rejectFollower(servers[2].url, servers[2].accessToken, 'peertube@localhost:9001')
+    await waitJobs(servers)
+
+    await checkServer1And2HasFollowers(servers)
+
+    {
+      const res = await getFollowersListPaginationAndSort(servers[ 2 ].url, 0, 5, 'createdAt')
+      expect(res.body.total).to.equal(0)
+    }
+  })
+
+  after(async function () {
+    await cleanupTests(servers)
+  })
+})
diff --git a/server/tests/api/server/follows.ts b/server/tests/api/server/follows.ts
index b0fc5d293..397093cdb 100644
--- a/server/tests/api/server/follows.ts
+++ b/server/tests/api/server/follows.ts
@@ -4,7 +4,7 @@ import * as chai from 'chai'
 import 'mocha'
 import { Video, VideoPrivacy } from '../../../../shared/models/videos'
 import { VideoComment, VideoCommentThreadTree } from '../../../../shared/models/videos/video-comment.model'
-import { completeVideoCheck } from '../../../../shared/utils'
+import { cleanupTests, completeVideoCheck } from '../../../../shared/extra-utils'
 import {
   flushAndRunMultipleServers,
   getVideosList,
@@ -12,26 +12,26 @@ import {
   ServerInfo,
   setAccessTokensToServers,
   uploadVideo
-} from '../../../../shared/utils/index'
-import { dateIsValid } from '../../../../shared/utils/miscs/miscs'
+} from '../../../../shared/extra-utils/index'
+import { dateIsValid } from '../../../../shared/extra-utils/miscs/miscs'
 import {
   follow,
   getFollowersListPaginationAndSort,
   getFollowingListPaginationAndSort,
   unfollow
-} from '../../../../shared/utils/server/follows'
-import { expectAccountFollows } from '../../../../shared/utils/users/accounts'
-import { userLogin } from '../../../../shared/utils/users/login'
-import { createUser } from '../../../../shared/utils/users/users'
+} from '../../../../shared/extra-utils/server/follows'
+import { expectAccountFollows } from '../../../../shared/extra-utils/users/accounts'
+import { userLogin } from '../../../../shared/extra-utils/users/login'
+import { createUser } from '../../../../shared/extra-utils/users/users'
 import {
   addVideoCommentReply,
   addVideoCommentThread,
   getVideoCommentThreads,
   getVideoThreadComments
-} from '../../../../shared/utils/videos/video-comments'
-import { rateVideo } from '../../../../shared/utils/videos/videos'
-import { waitJobs } from '../../../../shared/utils/server/jobs'
-import { createVideoCaption, listVideoCaptions, testCaptionFile } from '../../../../shared/utils/videos/video-captions'
+} from '../../../../shared/extra-utils/videos/video-comments'
+import { rateVideo } from '../../../../shared/extra-utils/videos/videos'
+import { waitJobs } from '../../../../shared/extra-utils/server/jobs'
+import { createVideoCaption, listVideoCaptions, testCaptionFile } from '../../../../shared/extra-utils/videos/video-captions'
 import { VideoCaption } from '../../../../shared/models/videos/caption/video-caption.model'
 
 const expect = chai.expect
@@ -241,7 +241,7 @@ describe('Test follows', function () {
     expect(res.body.data[0].name).to.equal('server3')
   })
 
-  describe('Should propagate data on a new following', async function () {
+  describe('Should propagate data on a new following', function () {
     let video4: Video
 
     before(async function () {
@@ -263,7 +263,7 @@ describe('Test follows', function () {
 
       {
         const user = { username: 'captain', password: 'password' }
-        await createUser(servers[ 2 ].url, servers[ 2 ].accessToken, user.username, user.password)
+        await createUser({ url: servers[ 2 ].url, accessToken: servers[ 2 ].accessToken, username: user.username, password: user.password })
         const userAccessToken = await userLogin(servers[ 2 ], user)
 
         const resVideos = await getVideosList(servers[ 2 ].url)
@@ -348,6 +348,7 @@ describe('Test follows', function () {
         },
         isLocal,
         commentsEnabled: true,
+        downloadEnabled: true,
         duration: 5,
         tags: [ 'tag1', 'tag2', 'tag3' ],
         privacy: VideoPrivacy.PUBLIC,
@@ -435,6 +436,6 @@ describe('Test follows', function () {
   })
 
   after(async function () {
-    killallServers(servers)
+    await cleanupTests(servers)
   })
 })
diff --git a/server/tests/api/server/handle-down.ts b/server/tests/api/server/handle-down.ts
index cd7baadad..19010dbc1 100644
--- a/server/tests/api/server/handle-down.ts
+++ b/server/tests/api/server/handle-down.ts
@@ -7,6 +7,7 @@ import { VideoPrivacy } from '../../../../shared/models/videos'
 import { VideoCommentThreadTree } from '../../../../shared/models/videos/video-comment.model'
 
 import {
+  cleanupTests,
   completeVideoCheck,
   flushAndRunMultipleServers,
   getVideo,
@@ -20,15 +21,15 @@ import {
   updateVideo,
   uploadVideo,
   wait
-} from '../../../../shared/utils'
-import { follow, getFollowersListPaginationAndSort } from '../../../../shared/utils/server/follows'
-import { getJobsListPaginationAndSort, waitJobs } from '../../../../shared/utils/server/jobs'
+} from '../../../../shared/extra-utils'
+import { follow, getFollowersListPaginationAndSort } from '../../../../shared/extra-utils/server/follows'
+import { getJobsListPaginationAndSort, waitJobs } from '../../../../shared/extra-utils/server/jobs'
 import {
   addVideoCommentReply,
   addVideoCommentThread,
   getVideoCommentThreads,
   getVideoThreadComments
-} from '../../../../shared/utils/videos/video-comments'
+} from '../../../../shared/extra-utils/videos/video-comments'
 
 const expect = chai.expect
 
@@ -76,6 +77,7 @@ describe('Test handle downs', function () {
     tags: [ 'tag1p1', 'tag2p1' ],
     privacy: VideoPrivacy.PUBLIC,
     commentsEnabled: true,
+    downloadEnabled: true,
     channel: {
       name: 'root_channel',
       displayName: 'Main root channel',
@@ -296,6 +298,6 @@ describe('Test handle downs', function () {
   })
 
   after(async function () {
-    killallServers(servers)
+    await cleanupTests(servers)
   })
 })
diff --git a/server/tests/api/server/index.ts b/server/tests/api/server/index.ts
index 1f80cc6cf..94c15e0d0 100644
--- a/server/tests/api/server/index.ts
+++ b/server/tests/api/server/index.ts
@@ -3,8 +3,10 @@ import './contact-form'
 import './email'
 import './follow-constraints'
 import './follows'
+import './follows-moderation'
 import './handle-down'
 import './jobs'
+import './logs'
 import './reverse-proxy'
 import './stats'
 import './tracker'
diff --git a/server/tests/api/server/jobs.ts b/server/tests/api/server/jobs.ts
index 52948b1d6..634654626 100644
--- a/server/tests/api/server/jobs.ts
+++ b/server/tests/api/server/jobs.ts
@@ -2,12 +2,12 @@
 
 import * as chai from 'chai'
 import 'mocha'
-import { killallServers, ServerInfo, setAccessTokensToServers } from '../../../../shared/utils/index'
-import { doubleFollow } from '../../../../shared/utils/server/follows'
-import { getJobsList, getJobsListPaginationAndSort, waitJobs } from '../../../../shared/utils/server/jobs'
-import { flushAndRunMultipleServers } from '../../../../shared/utils/server/servers'
-import { uploadVideo } from '../../../../shared/utils/videos/videos'
-import { dateIsValid } from '../../../../shared/utils/miscs/miscs'
+import { cleanupTests, killallServers, ServerInfo, setAccessTokensToServers } from '../../../../shared/extra-utils/index'
+import { doubleFollow } from '../../../../shared/extra-utils/server/follows'
+import { getJobsList, getJobsListPaginationAndSort, waitJobs } from '../../../../shared/extra-utils/server/jobs'
+import { flushAndRunMultipleServers } from '../../../../shared/extra-utils/server/servers'
+import { uploadVideo } from '../../../../shared/extra-utils/videos/videos'
+import { dateIsValid } from '../../../../shared/extra-utils/miscs/miscs'
 
 const expect = chai.expect
 
@@ -57,6 +57,6 @@ describe('Test jobs', function () {
   })
 
   after(async function () {
-    killallServers(servers)
+    await cleanupTests(servers)
   })
 })
diff --git a/server/tests/api/server/logs.ts b/server/tests/api/server/logs.ts
new file mode 100644
index 000000000..3644fa0d3
--- /dev/null
+++ b/server/tests/api/server/logs.ts
@@ -0,0 +1,97 @@
+/* tslint:disable:no-unused-expression */
+
+import * as chai from 'chai'
+import 'mocha'
+import {
+  flushTests,
+  killallServers,
+  flushAndRunServer,
+  ServerInfo,
+  setAccessTokensToServers,
+  cleanupTests
+} from '../../../../shared/extra-utils/index'
+import { waitJobs } from '../../../../shared/extra-utils/server/jobs'
+import { uploadVideo } from '../../../../shared/extra-utils/videos/videos'
+import { getLogs } from '../../../../shared/extra-utils/logs/logs'
+
+const expect = chai.expect
+
+describe('Test logs', function () {
+  let server: ServerInfo
+
+  before(async function () {
+    this.timeout(30000)
+
+    server = await flushAndRunServer(1)
+    await setAccessTokensToServers([ server ])
+  })
+
+  it('Should get logs with a start date', async function () {
+    this.timeout(10000)
+
+    await uploadVideo(server.url, server.accessToken, { name: 'video 1' })
+    await waitJobs([ server ])
+
+    const now = new Date()
+
+    await uploadVideo(server.url, server.accessToken, { name: 'video 2' })
+    await waitJobs([ server ])
+
+    const res = await getLogs(server.url, server.accessToken, now)
+    const logsString = JSON.stringify(res.body)
+
+    expect(logsString.includes('video 1')).to.be.false
+    expect(logsString.includes('video 2')).to.be.true
+  })
+
+  it('Should get logs with an end date', async function () {
+    this.timeout(10000)
+
+    await uploadVideo(server.url, server.accessToken, { name: 'video 3' })
+    await waitJobs([ server ])
+
+    const now1 = new Date()
+
+    await uploadVideo(server.url, server.accessToken, { name: 'video 4' })
+    await waitJobs([ server ])
+
+    const now2 = new Date()
+
+    await uploadVideo(server.url, server.accessToken, { name: 'video 5' })
+    await waitJobs([ server ])
+
+    const res = await getLogs(server.url, server.accessToken, now1, now2)
+    const logsString = JSON.stringify(res.body)
+
+    expect(logsString.includes('video 3')).to.be.false
+    expect(logsString.includes('video 4')).to.be.true
+    expect(logsString.includes('video 5')).to.be.false
+  })
+
+  it('Should get filter by level', async function () {
+    this.timeout(10000)
+
+    const now = new Date()
+
+    await uploadVideo(server.url, server.accessToken, { name: 'video 6' })
+    await waitJobs([ server ])
+
+    {
+      const res = await getLogs(server.url, server.accessToken, now, undefined, 'info')
+      const logsString = JSON.stringify(res.body)
+
+      expect(logsString.includes('video 6')).to.be.true
+    }
+
+    {
+      const res = await getLogs(server.url, server.accessToken, now, undefined, 'warn')
+      const logsString = JSON.stringify(res.body)
+
+      expect(logsString.includes('video 6')).to.be.false
+    }
+  })
+
+  after(async function () {
+    await cleanupTests([ server ])
+  })
+})
diff --git a/server/tests/api/server/no-client.ts b/server/tests/api/server/no-client.ts
index 3b95ce945..86edeb289 100644
--- a/server/tests/api/server/no-client.ts
+++ b/server/tests/api/server/no-client.ts
@@ -1,11 +1,7 @@
 import 'mocha'
 import * as request from 'supertest'
-import {
-  flushTests,
-  killallServers,
-  ServerInfo
-} from '../../../../shared/utils'
-import { runServer } from '../../../../shared/utils/server/servers'
+import { ServerInfo } from '../../../../shared/extra-utils'
+import { cleanupTests, flushAndRunServer } from '../../../../shared/extra-utils/server/servers'
 
 describe('Start and stop server without web client routes', function () {
   let server: ServerInfo
@@ -13,9 +9,7 @@ describe('Start and stop server without web client routes', function () {
   before(async function () {
     this.timeout(30000)
 
-    await flushTests()
-
-    server = await runServer(1, {}, ['--no-client'])
+    server = await flushAndRunServer(1, {}, ['--no-client'])
   })
 
   it('Should fail getting the client', function () {
@@ -26,11 +20,6 @@ describe('Start and stop server without web client routes', function () {
   })
 
   after(async function () {
-    killallServers([ server ])
-
-    // Keep the logs if the test failed
-    if (this['ok']) {
-      await flushTests()
-    }
+    await cleanupTests([ server ])
   })
 })
diff --git a/server/tests/api/server/reverse-proxy.ts b/server/tests/api/server/reverse-proxy.ts
index d4c08c346..987538237 100644
--- a/server/tests/api/server/reverse-proxy.ts
+++ b/server/tests/api/server/reverse-proxy.ts
@@ -2,28 +2,10 @@
 
 import 'mocha'
 import * as chai from 'chai'
-import { About } from '../../../../shared/models/server/about.model'
-import { CustomConfig } from '../../../../shared/models/server/custom-config.model'
-import {
-  deleteCustomConfig,
-  getAbout,
-  getVideo,
-  killallServers,
-  login,
-  reRunServer,
-  uploadVideo,
-  userLogin,
-  viewVideo,
-  wait
-} from '../../../../shared/utils'
-const expect = chai.expect
+import { cleanupTests, getVideo, uploadVideo, userLogin, viewVideo, wait } from '../../../../shared/extra-utils'
+import { flushAndRunServer, setAccessTokensToServers } from '../../../../shared/extra-utils/index'
 
-import {
-  getConfig,
-  flushTests,
-  runServer,
-  registerUser, getCustomConfig, setAccessTokensToServers, updateCustomConfig
-} from '../../../../shared/utils/index'
+const expect = chai.expect
 
 describe('Test application behind a reverse proxy', function () {
   let server = null
@@ -31,9 +13,7 @@ describe('Test application behind a reverse proxy', function () {
 
   before(async function () {
     this.timeout(30000)
-
-    await flushTests()
-    server = await runServer(1)
+    server = await flushAndRunServer(1)
     await setAccessTokensToServers([ server ])
 
     const { body } = await uploadVideo(server.url, server.accessToken, {})
@@ -95,7 +75,7 @@ describe('Test application behind a reverse proxy', function () {
   it('Should rate limit logins', async function () {
     const user = { username: 'root', password: 'fail' }
 
-    for (let i = 0; i < 14; i++) {
+    for (let i = 0; i < 19; i++) {
       await userLogin(server, user, 400)
     }
 
@@ -103,6 +83,6 @@ describe('Test application behind a reverse proxy', function () {
   })
 
   after(async function () {
-    killallServers([ server ])
+    await cleanupTests([ server ])
   })
 })
diff --git a/server/tests/api/server/stats.ts b/server/tests/api/server/stats.ts
index aaa6c62f7..a01cd4b38 100644
--- a/server/tests/api/server/stats.ts
+++ b/server/tests/api/server/stats.ts
@@ -4,6 +4,7 @@ import * as chai from 'chai'
 import 'mocha'
 import { ServerStats } from '../../../../shared/models/server/server-stats.model'
 import {
+  cleanupTests,
   createUser,
   doubleFollow,
   flushAndRunMultipleServers,
@@ -13,11 +14,11 @@ import {
   uploadVideo,
   viewVideo,
   wait
-} from '../../../../shared/utils'
-import { flushTests, setAccessTokensToServers } from '../../../../shared/utils/index'
-import { getStats } from '../../../../shared/utils/server/stats'
-import { addVideoCommentThread } from '../../../../shared/utils/videos/video-comments'
-import { waitJobs } from '../../../../shared/utils/server/jobs'
+} from '../../../../shared/extra-utils'
+import { flushTests, setAccessTokensToServers } from '../../../../shared/extra-utils/index'
+import { getStats } from '../../../../shared/extra-utils/server/stats'
+import { addVideoCommentThread } from '../../../../shared/extra-utils/videos/video-comments'
+import { waitJobs } from '../../../../shared/extra-utils/server/jobs'
 
 const expect = chai.expect
 
@@ -26,8 +27,6 @@ describe('Test stats (excluding redundancy)', function () {
 
   before(async function () {
     this.timeout(60000)
-
-    await flushTests()
     servers = await flushAndRunMultipleServers(3)
     await setAccessTokensToServers(servers)
 
@@ -37,7 +36,7 @@ describe('Test stats (excluding redundancy)', function () {
       username: 'user1',
       password: 'super_password'
     }
-    await createUser(servers[0].url, servers[0].accessToken, user.username, user.password)
+    await createUser({ url: servers[ 0 ].url, accessToken: servers[ 0 ].accessToken, username: user.username, password: user.password })
 
     const resVideo = await uploadVideo(servers[0].url, servers[0].accessToken, { fixture: 'video_short.webm' })
     const videoUUID = resVideo.body.video.uuid
@@ -98,6 +97,6 @@ describe('Test stats (excluding redundancy)', function () {
   })
 
   after(async function () {
-    killallServers(servers)
+    await cleanupTests(servers)
   })
 })
diff --git a/server/tests/api/server/tracker.ts b/server/tests/api/server/tracker.ts
index 25ca00029..9d7eec8ca 100644
--- a/server/tests/api/server/tracker.ts
+++ b/server/tests/api/server/tracker.ts
@@ -2,8 +2,16 @@
 
 import * as magnetUtil from 'magnet-uri'
 import 'mocha'
-import { getVideo, killallServers, runServer, ServerInfo, uploadVideo } from '../../../../shared/utils'
-import { flushTests, setAccessTokensToServers } from '../../../../shared/utils/index'
+import {
+  cleanupTests,
+  flushAndRunServer,
+  getVideo,
+  killallServers,
+  reRunServer,
+  ServerInfo,
+  uploadVideo
+} from '../../../../shared/extra-utils'
+import { setAccessTokensToServers } from '../../../../shared/extra-utils/index'
 import { VideoDetails } from '../../../../shared/models/videos'
 import * as WebTorrent from 'webtorrent'
 
@@ -14,9 +22,7 @@ describe('Test tracker', function () {
 
   before(async function () {
     this.timeout(60000)
-
-    await flushTests()
-    server = await runServer(1)
+    server = await flushAndRunServer(1)
     await setAccessTokensToServers([ server ])
 
     {
@@ -34,7 +40,7 @@ describe('Test tracker', function () {
     }
   })
 
-  it('Should return an error when adding an incorrect infohash', done => {
+  it('Should return an error when adding an incorrect infohash', function (done) {
     this.timeout(10000)
     const webtorrent = new WebTorrent()
 
@@ -49,7 +55,7 @@ describe('Test tracker', function () {
     torrent.on('done', () => done(new Error('No error on infohash')))
   })
 
-  it('Should succeed with the correct infohash', done => {
+  it('Should succeed with the correct infohash', function (done) {
     this.timeout(10000)
     const webtorrent = new WebTorrent()
 
@@ -64,7 +70,27 @@ describe('Test tracker', function () {
     torrent.on('done', done)
   })
 
-  after(async function () {
+  it('Should disable the tracker', function (done) {
+    this.timeout(20000)
+
     killallServers([ server ])
+    reRunServer(server, { tracker: { enabled: false } })
+      .then(() => {
+        const webtorrent = new WebTorrent()
+
+        const torrent = webtorrent.add(goodMagnet)
+
+        torrent.on('error', done)
+        torrent.on('warning', warn => {
+          const message = typeof warn === 'string' ? warn : warn.message
+          if (message.indexOf('disabled ') !== -1) return done()
+        })
+
+        torrent.on('done', () => done(new Error('Tracker is enabled')))
+      })
+  })
+
+  after(async function () {
+    await cleanupTests([ server ])
   })
 })
diff --git a/server/tests/api/users/blocklist.ts b/server/tests/api/users/blocklist.ts
index 4bca27a94..fbc57e0ef 100644
--- a/server/tests/api/users/blocklist.ts
+++ b/server/tests/api/users/blocklist.ts
@@ -4,6 +4,7 @@ import * as chai from 'chai'
 import 'mocha'
 import { AccountBlock, ServerBlock, Video } from '../../../../shared/index'
 import {
+  cleanupTests,
   createUser,
   doubleFollow,
   flushAndRunMultipleServers,
@@ -12,16 +13,16 @@ import {
   ServerInfo,
   uploadVideo,
   userLogin
-} from '../../../../shared/utils/index'
-import { setAccessTokensToServers } from '../../../../shared/utils/users/login'
-import { getVideosListWithToken, getVideosList } from '../../../../shared/utils/videos/videos'
+} from '../../../../shared/extra-utils/index'
+import { setAccessTokensToServers } from '../../../../shared/extra-utils/users/login'
+import { getVideosListWithToken, getVideosList } from '../../../../shared/extra-utils/videos/videos'
 import {
   addVideoCommentReply,
   addVideoCommentThread,
   getVideoCommentThreads,
   getVideoThreadComments
-} from '../../../../shared/utils/videos/video-comments'
-import { waitJobs } from '../../../../shared/utils/server/jobs'
+} from '../../../../shared/extra-utils/videos/video-comments'
+import { waitJobs } from '../../../../shared/extra-utils/server/jobs'
 import { VideoComment, VideoCommentThreadTree } from '../../../../shared/models/videos/video-comment.model'
 import {
   addAccountToAccountBlocklist,
@@ -36,7 +37,7 @@ import {
   removeAccountFromServerBlocklist,
   removeServerFromAccountBlocklist,
   removeServerFromServerBlocklist
-} from '../../../../shared/utils/users/blocklist'
+} from '../../../../shared/extra-utils/users/blocklist'
 
 const expect = chai.expect
 
@@ -79,14 +80,12 @@ describe('Test blocklist', function () {
   before(async function () {
     this.timeout(60000)
 
-    await flushTests()
-
     servers = await flushAndRunMultipleServers(2)
     await setAccessTokensToServers(servers)
 
     {
       const user = { username: 'user1', password: 'password' }
-      await createUser(servers[0].url, servers[0].accessToken, user.username, user.password)
+      await createUser({ url: servers[ 0 ].url, accessToken: servers[ 0 ].accessToken, username: user.username, password: user.password })
 
       userToken1 = await userLogin(servers[0], user)
       await uploadVideo(servers[0].url, userToken1, { name: 'video user 1' })
@@ -94,14 +93,14 @@ describe('Test blocklist', function () {
 
     {
       const user = { username: 'moderator', password: 'password' }
-      await createUser(servers[0].url, servers[0].accessToken, user.username, user.password)
+      await createUser({ url: servers[ 0 ].url, accessToken: servers[ 0 ].accessToken, username: user.username, password: user.password })
 
       userModeratorToken = await userLogin(servers[0], user)
     }
 
     {
       const user = { username: 'user2', password: 'password' }
-      await createUser(servers[1].url, servers[1].accessToken, user.username, user.password)
+      await createUser({ url: servers[ 1 ].url, accessToken: servers[ 1 ].accessToken, username: user.username, password: user.password })
 
       userToken2 = await userLogin(servers[1], user)
       await uploadVideo(servers[1].url, userToken2, { name: 'video user 2' })
@@ -501,11 +500,6 @@ describe('Test blocklist', function () {
   })
 
   after(async function () {
-    killallServers(servers)
-
-    // Keep the logs if the test failed
-    if (this[ 'ok' ]) {
-      await flushTests()
-    }
+    await cleanupTests(servers)
   })
 })
diff --git a/server/tests/api/users/index.ts b/server/tests/api/users/index.ts
index 52ba6984e..fcd022429 100644
--- a/server/tests/api/users/index.ts
+++ b/server/tests/api/users/index.ts
@@ -1,5 +1,4 @@
 import './users-verification'
-import './user-notifications'
 import './blocklist'
 import './user-subscriptions'
 import './users'
diff --git a/server/tests/api/users/user-subscriptions.ts b/server/tests/api/users/user-subscriptions.ts
index 88a7187d6..48811e647 100644
--- a/server/tests/api/users/user-subscriptions.ts
+++ b/server/tests/api/users/user-subscriptions.ts
@@ -3,6 +3,7 @@
 import * as chai from 'chai'
 import 'mocha'
 import {
+  cleanupTests,
   createUser,
   doubleFollow,
   flushAndRunMultipleServers,
@@ -11,18 +12,18 @@ import {
   unfollow,
   updateVideo,
   userLogin
-} from '../../../../shared/utils'
-import { killallServers, ServerInfo, uploadVideo } from '../../../../shared/utils/index'
-import { setAccessTokensToServers } from '../../../../shared/utils/users/login'
+} from '../../../../shared/extra-utils'
+import { killallServers, ServerInfo, uploadVideo } from '../../../../shared/extra-utils/index'
+import { setAccessTokensToServers } from '../../../../shared/extra-utils/users/login'
 import { Video, VideoChannel } from '../../../../shared/models/videos'
-import { waitJobs } from '../../../../shared/utils/server/jobs'
+import { waitJobs } from '../../../../shared/extra-utils/server/jobs'
 import {
   addUserSubscription,
   listUserSubscriptions,
   listUserSubscriptionVideos,
   removeUserSubscription,
   getUserSubscription, areSubscriptionsExist
-} from '../../../../shared/utils/users/user-subscriptions'
+} from '../../../../shared/extra-utils/users/user-subscriptions'
 
 const expect = chai.expect
 
@@ -45,7 +46,7 @@ describe('Test users subscriptions', function () {
     {
       for (const server of servers) {
         const user = { username: 'user' + server.serverNumber, password: 'password' }
-        await createUser(server.url, server.accessToken, user.username, user.password)
+        await createUser({ url: server.url, accessToken: server.accessToken, username: user.username, password: user.password })
 
         const accessToken = await userLogin(server, user)
         users.push({ accessToken })
@@ -369,6 +370,6 @@ describe('Test users subscriptions', function () {
   })
 
   after(async function () {
-    killallServers(servers)
+    await cleanupTests(servers)
   })
 })
diff --git a/server/tests/api/users/users-multiple-servers.ts b/server/tests/api/users/users-multiple-servers.ts
index 006d6cdf0..9a971adb3 100644
--- a/server/tests/api/users/users-multiple-servers.ts
+++ b/server/tests/api/users/users-multiple-servers.ts
@@ -4,7 +4,8 @@ import * as chai from 'chai'
 import 'mocha'
 import { Account } from '../../../../shared/models/actors'
 import {
-  checkVideoFilesWereRemoved,
+  checkTmpIsEmpty,
+  checkVideoFilesWereRemoved, cleanupTests,
   createUser,
   doubleFollow,
   flushAndRunMultipleServers,
@@ -13,13 +14,20 @@ import {
   removeUser,
   updateMyUser,
   userLogin
-} from '../../../../shared/utils'
-import { getMyUserInformation, killallServers, ServerInfo, testImage, updateMyAvatar, uploadVideo } from '../../../../shared/utils/index'
-import { checkActorFilesWereRemoved, getAccount, getAccountsList } from '../../../../shared/utils/users/accounts'
-import { setAccessTokensToServers } from '../../../../shared/utils/users/login'
+} from '../../../../shared/extra-utils'
+import {
+  getMyUserInformation,
+  killallServers,
+  ServerInfo,
+  testImage,
+  updateMyAvatar,
+  uploadVideo
+} from '../../../../shared/extra-utils/index'
+import { checkActorFilesWereRemoved, getAccount, getAccountsList } from '../../../../shared/extra-utils/users/accounts'
+import { setAccessTokensToServers } from '../../../../shared/extra-utils/users/login'
 import { User } from '../../../../shared/models/users'
 import { VideoChannel } from '../../../../shared/models/videos'
-import { waitJobs } from '../../../../shared/utils/server/jobs'
+import { waitJobs } from '../../../../shared/extra-utils/server/jobs'
 
 const expect = chai.expect
 
@@ -56,7 +64,12 @@ describe('Test users with multiple servers', function () {
         username: 'user1',
         password: 'password'
       }
-      const res = await createUser(servers[ 0 ].url, servers[ 0 ].accessToken, user.username, user.password)
+      const res = await createUser({
+        url: servers[ 0 ].url,
+        accessToken: servers[ 0 ].accessToken,
+        username: user.username,
+        password: user.password
+      })
       userId = res.body.user.id
       userAccessToken = await userLogin(servers[ 0 ], user)
     }
@@ -216,7 +229,13 @@ describe('Test users with multiple servers', function () {
     }
   })
 
+  it('Should have an empty tmp directory', async function () {
+    for (const server of servers) {
+      await checkTmpIsEmpty(server)
+    }
+  })
+
   after(async function () {
-    killallServers(servers)
+    await cleanupTests(servers)
   })
 })
diff --git a/server/tests/api/users/users-verification.ts b/server/tests/api/users/users-verification.ts
index babeda2b8..514acf2e7 100644
--- a/server/tests/api/users/users-verification.ts
+++ b/server/tests/api/users/users-verification.ts
@@ -4,11 +4,11 @@ import * as chai from 'chai'
 import 'mocha'
 import {
   registerUser, flushTests, getUserInformation, getMyUserInformation, killallServers,
-  userLogin, login, runServer, ServerInfo, verifyEmail, updateCustomSubConfig, wait
-} from '../../../../shared/utils'
-import { setAccessTokensToServers } from '../../../../shared/utils/users/login'
-import { MockSmtpServer } from '../../../../shared/utils/miscs/email'
-import { waitJobs } from '../../../../shared/utils/server/jobs'
+  userLogin, login, flushAndRunServer, ServerInfo, verifyEmail, updateCustomSubConfig, wait, cleanupTests
+} from '../../../../shared/extra-utils'
+import { setAccessTokensToServers } from '../../../../shared/extra-utils/users/login'
+import { MockSmtpServer } from '../../../../shared/extra-utils/miscs/email'
+import { waitJobs } from '../../../../shared/extra-utils/server/jobs'
 
 const expect = chai.expect
 
@@ -32,14 +32,12 @@ describe('Test users account verification', function () {
 
     await MockSmtpServer.Instance.collectEmails(emails)
 
-    await flushTests()
-
     const overrideConfig = {
       smtp: {
         hostname: 'localhost'
       }
     }
-    server = await runServer(1, overrideConfig)
+    server = await flushAndRunServer(1, overrideConfig)
 
     await setAccessTokensToServers([ server ])
   })
@@ -124,11 +122,7 @@ describe('Test users account verification', function () {
 
   after(async function () {
     MockSmtpServer.Instance.kill()
-    killallServers([ server ])
 
-    // Keep the logs if the test failed
-    if (this[ 'ok' ]) {
-      await flushTests()
-    }
+    await cleanupTests([ server ])
   })
 })
diff --git a/server/tests/api/users/users.ts b/server/tests/api/users/users.ts
index ad98ab1c7..c8e32f3f5 100644
--- a/server/tests/api/users/users.ts
+++ b/server/tests/api/users/users.ts
@@ -2,12 +2,14 @@
 
 import * as chai from 'chai'
 import 'mocha'
-import { User, UserRole } from '../../../../shared/index'
+import { User, UserRole, Video } from '../../../../shared/index'
 import {
   blockUser,
+  cleanupTests,
   createUser,
   deleteMe,
-  flushTests,
+  flushAndRunServer,
+  getAccountRatings,
   getBlacklistedVideosList,
   getMyUserInformation,
   getMyUserVideoQuotaUsed,
@@ -16,14 +18,12 @@ import {
   getUsersList,
   getUsersListPaginationAndSort,
   getVideosList,
-  killallServers,
   login,
   makePutBodyRequest,
   rateVideo,
   registerUser,
   removeUser,
   removeVideo,
-  runServer,
   ServerInfo,
   testImage,
   unblockUser,
@@ -32,10 +32,11 @@ import {
   updateUser,
   uploadVideo,
   userLogin
-} from '../../../../shared/utils/index'
-import { follow } from '../../../../shared/utils/server/follows'
-import { setAccessTokensToServers } from '../../../../shared/utils/users/login'
-import { getMyVideos } from '../../../../shared/utils/videos/videos'
+} from '../../../../shared/extra-utils'
+import { follow } from '../../../../shared/extra-utils/server/follows'
+import { setAccessTokensToServers } from '../../../../shared/extra-utils/users/login'
+import { getMyVideos } from '../../../../shared/extra-utils/videos/videos'
+import { UserAdminFlag } from '../../../../shared/models/users/user-flag.model'
 
 const expect = chai.expect
 
@@ -52,537 +53,633 @@ describe('Test users', function () {
 
   before(async function () {
     this.timeout(30000)
-
-    await flushTests()
-    server = await runServer(1)
+    server = await flushAndRunServer(1)
 
     await setAccessTokensToServers([ server ])
   })
 
-  it('Should create a new client')
+  describe('OAuth client', function () {
+    it('Should create a new client')
 
-  it('Should return the first client')
+    it('Should return the first client')
 
-  it('Should remove the last client')
+    it('Should remove the last client')
 
-  it('Should not login with an invalid client id', async function () {
-    const client = { id: 'client', secret: server.client.secret }
-    const res = await login(server.url, client, server.user, 400)
+    it('Should not login with an invalid client id', async function () {
+      const client = { id: 'client', secret: server.client.secret }
+      const res = await login(server.url, client, server.user, 400)
 
-    expect(res.body.error).to.contain('client is invalid')
-  })
+      expect(res.body.error).to.contain('client is invalid')
+    })
 
-  it('Should not login with an invalid client secret', async function () {
-    const client = { id: server.client.id, secret: 'coucou' }
-    const res = await login(server.url, client, server.user, 400)
+    it('Should not login with an invalid client secret', async function () {
+      const client = { id: server.client.id, secret: 'coucou' }
+      const res = await login(server.url, client, server.user, 400)
 
-    expect(res.body.error).to.contain('client is invalid')
+      expect(res.body.error).to.contain('client is invalid')
+    })
   })
 
-  it('Should not login with an invalid username', async function () {
-    const user = { username: 'captain crochet', password: server.user.password }
-    const res = await login(server.url, server.client, user, 400)
+  describe('Login', function () {
 
-    expect(res.body.error).to.contain('credentials are invalid')
-  })
-
-  it('Should not login with an invalid password', async function () {
-    const user = { username: server.user.username, password: 'mew_three' }
-    const res = await login(server.url, server.client, user, 400)
+    it('Should not login with an invalid username', async function () {
+      const user = { username: 'captain crochet', password: server.user.password }
+      const res = await login(server.url, server.client, user, 400)
 
-    expect(res.body.error).to.contain('credentials are invalid')
-  })
+      expect(res.body.error).to.contain('credentials are invalid')
+    })
 
-  it('Should not be able to upload a video', async function () {
-    accessToken = 'my_super_token'
+    it('Should not login with an invalid password', async function () {
+      const user = { username: server.user.username, password: 'mew_three' }
+      const res = await login(server.url, server.client, user, 400)
 
-    const videoAttributes = {}
-    await uploadVideo(server.url, accessToken, videoAttributes, 401)
-  })
+      expect(res.body.error).to.contain('credentials are invalid')
+    })
 
-  it('Should not be able to follow', async function () {
-    accessToken = 'my_super_token'
-    await follow(server.url, [ 'http://example.com' ], accessToken, 401)
-  })
+    it('Should not be able to upload a video', async function () {
+      accessToken = 'my_super_token'
 
-  it('Should not be able to unfollow')
+      const videoAttributes = {}
+      await uploadVideo(server.url, accessToken, videoAttributes, 401)
+    })
 
-  it('Should be able to login', async function () {
-    const res = await login(server.url, server.client, server.user, 200)
+    it('Should not be able to follow', async function () {
+      accessToken = 'my_super_token'
+      await follow(server.url, [ 'http://example.com' ], accessToken, 401)
+    })
 
-    accessToken = res.body.access_token
-  })
+    it('Should not be able to unfollow')
 
-  it('Should upload the video with the correct token', async function () {
-    const videoAttributes = {}
-    await uploadVideo(server.url, accessToken, videoAttributes)
-    const res = await getVideosList(server.url)
-    const video = res.body.data[ 0 ]
+    it('Should be able to login', async function () {
+      const res = await login(server.url, server.client, server.user, 200)
 
-    expect(video.account.name).to.equal('root')
-    videoId = video.id
+      accessToken = res.body.access_token
+    })
   })
 
-  it('Should upload the video again with the correct token', async function () {
-    const videoAttributes = {}
-    await uploadVideo(server.url, accessToken, videoAttributes)
-  })
+  describe('Upload', function () {
 
-  it('Should retrieve a video rating', async function () {
-    await rateVideo(server.url, accessToken, videoId, 'like')
-    const res = await getMyUserVideoRating(server.url, accessToken, videoId)
-    const rating = res.body
+    it('Should upload the video with the correct token', async function () {
+      const videoAttributes = {}
+      await uploadVideo(server.url, accessToken, videoAttributes)
+      const res = await getVideosList(server.url)
+      const video = res.body.data[ 0 ]
 
-    expect(rating.videoId).to.equal(videoId)
-    expect(rating.rating).to.equal('like')
-  })
+      expect(video.account.name).to.equal('root')
+      videoId = video.id
+    })
 
-  it('Should not be able to remove the video with an incorrect token', async function () {
-    await removeVideo(server.url, 'bad_token', videoId, 401)
+    it('Should upload the video again with the correct token', async function () {
+      const videoAttributes = {}
+      await uploadVideo(server.url, accessToken, videoAttributes)
+    })
   })
 
-  it('Should not be able to remove the video with the token of another account')
+  describe('Ratings', function () {
 
-  it('Should be able to remove the video with the correct token', async function () {
-    await removeVideo(server.url, accessToken, videoId)
-  })
+    it('Should retrieve a video rating', async function () {
+      await rateVideo(server.url, accessToken, videoId, 'like')
+      const res = await getMyUserVideoRating(server.url, accessToken, videoId)
+      const rating = res.body
 
-  it('Should logout (revoke token)')
-
-  it('Should not be able to get the user information')
+      expect(rating.videoId).to.equal(videoId)
+      expect(rating.rating).to.equal('like')
+    })
 
-  it('Should not be able to upload a video')
+    it('Should retrieve ratings list', async function () {
+      await rateVideo(server.url, accessToken, videoId, 'like')
 
-  it('Should not be able to remove a video')
+      const res = await getAccountRatings(server.url, server.user.username, server.accessToken, null, 200)
+      const ratings = res.body
 
-  it('Should not be able to rate a video', async function () {
-    const path = '/api/v1/videos/'
-    const data = {
-      rating: 'likes'
-    }
+      expect(ratings.total).to.equal(1)
+      expect(ratings.data[ 0 ].video.id).to.equal(videoId)
+      expect(ratings.data[ 0 ].rating).to.equal('like')
+    })
 
-    const options = {
-      url: server.url,
-      path: path + videoId,
-      token: 'wrong token',
-      fields: data,
-      statusCodeExpected: 401
-    }
-    await makePutBodyRequest(options)
+    it('Should retrieve ratings list by rating type', async function () {
+      {
+        const res = await getAccountRatings(server.url, server.user.username, server.accessToken, 'like')
+        const ratings = res.body
+        expect(ratings.data.length).to.equal(1)
+      }
+
+      {
+        const res = await getAccountRatings(server.url, server.user.username, server.accessToken, 'dislike')
+        const ratings = res.body
+        expect(ratings.data.length).to.equal(0)
+      }
+    })
   })
 
-  it('Should be able to login again')
+  describe('Remove video', function () {
+    it('Should not be able to remove the video with an incorrect token', async function () {
+      await removeVideo(server.url, 'bad_token', videoId, 401)
+    })
 
-  it('Should have an expired access token')
+    it('Should not be able to remove the video with the token of another account')
 
-  it('Should refresh the token')
+    it('Should be able to remove the video with the correct token', async function () {
+      await removeVideo(server.url, accessToken, videoId)
+    })
+  })
 
-  it('Should be able to upload a video again')
+  describe('Logout', function () {
+    it('Should logout (revoke token)')
 
-  it('Should be able to create a new user', async function () {
-    await createUser(server.url, accessToken, user.username, user.password, 2 * 1024 * 1024)
-  })
+    it('Should not be able to get the user information')
 
-  it('Should be able to login with this user', async function () {
-    accessTokenUser = await userLogin(server, user)
-  })
+    it('Should not be able to upload a video')
 
-  it('Should be able to get the user information', async function () {
-    const res = await getMyUserInformation(server.url, accessTokenUser)
-    const user = res.body
-
-    expect(user.username).to.equal('user_1')
-    expect(user.email).to.equal('user_1@example.com')
-    expect(user.nsfwPolicy).to.equal('display')
-    expect(user.videoQuota).to.equal(2 * 1024 * 1024)
-    expect(user.roleLabel).to.equal('User')
-    expect(user.id).to.be.a('number')
-    expect(user.account.displayName).to.equal('user_1')
-    expect(user.account.description).to.be.null
-  })
+    it('Should not be able to remove a video')
 
-  it('Should be able to upload a video with this user', async function () {
-    this.timeout(5000)
+    it('Should not be able to rate a video', async function () {
+      const path = '/api/v1/videos/'
+      const data = {
+        rating: 'likes'
+      }
 
-    const videoAttributes = {
-      name: 'super user video',
-      fixture: 'video_short.webm'
-    }
-    await uploadVideo(server.url, accessTokenUser, videoAttributes)
-  })
+      const options = {
+        url: server.url,
+        path: path + videoId,
+        token: 'wrong token',
+        fields: data,
+        statusCodeExpected: 401
+      }
+      await makePutBodyRequest(options)
+    })
 
-  it('Should have video quota updated', async function () {
-    const res = await getMyUserVideoQuotaUsed(server.url, accessTokenUser)
-    const data = res.body
+    it('Should be able to login again')
 
-    expect(data.videoQuotaUsed).to.equal(218910)
+    it('Should have an expired access token')
 
-    const resUsers = await getUsersList(server.url, server.accessToken)
+    it('Should refresh the token')
 
-    const users: User[] = resUsers.body.data
-    const tmpUser = users.find(u => u.username === user.username)
-    expect(tmpUser.videoQuotaUsed).to.equal(218910)
+    it('Should be able to upload a video again')
   })
 
-  it('Should be able to list my videos', async function () {
-    const res = await getMyVideos(server.url, accessTokenUser, 0, 5)
-    expect(res.body.total).to.equal(1)
+  describe('Creating a user', function () {
 
-    const videos = res.body.data
-    expect(videos).to.have.lengthOf(1)
+    it('Should be able to create a new user', async function () {
+      await createUser({
+        url: server.url,
+        accessToken: accessToken,
+        username: user.username,
+        password: user.password,
+        videoQuota: 2 * 1024 * 1024,
+        adminFlags: UserAdminFlag.BY_PASS_VIDEO_AUTO_BLACKLIST
+      })
+    })
 
-    expect(videos[ 0 ].name).to.equal('super user video')
+    it('Should be able to login with this user', async function () {
+      accessTokenUser = await userLogin(server, user)
+    })
+
+    it('Should be able to get user information', async function () {
+      const res1 = await getMyUserInformation(server.url, accessTokenUser)
+      const userMe: User = res1.body
+
+      const res2 = await getUserInformation(server.url, server.accessToken, userMe.id)
+      const userGet: User = res2.body
+
+      for (const user of [ userMe, userGet ]) {
+        expect(user.username).to.equal('user_1')
+        expect(user.email).to.equal('user_1@example.com')
+        expect(user.nsfwPolicy).to.equal('display')
+        expect(user.videoQuota).to.equal(2 * 1024 * 1024)
+        expect(user.roleLabel).to.equal('User')
+        expect(user.id).to.be.a('number')
+        expect(user.account.displayName).to.equal('user_1')
+        expect(user.account.description).to.be.null
+      }
+
+      expect(userMe.adminFlags).to.be.undefined
+      expect(userGet.adminFlags).to.equal(UserAdminFlag.BY_PASS_VIDEO_AUTO_BLACKLIST)
+    })
   })
 
-  it('Should list all the users', async function () {
-    const res = await getUsersList(server.url, server.accessToken)
-    const result = res.body
-    const total = result.total
-    const users = result.data
+  describe('My videos & quotas', function () {
 
-    expect(total).to.equal(2)
-    expect(users).to.be.an('array')
-    expect(users.length).to.equal(2)
+    it('Should be able to upload a video with this user', async function () {
+      this.timeout(5000)
 
-    const user = users[ 0 ]
-    expect(user.username).to.equal('user_1')
-    expect(user.email).to.equal('user_1@example.com')
-    expect(user.nsfwPolicy).to.equal('display')
+      const videoAttributes = {
+        name: 'super user video',
+        fixture: 'video_short.webm'
+      }
+      await uploadVideo(server.url, accessTokenUser, videoAttributes)
+    })
 
-    const rootUser = users[ 1 ]
-    expect(rootUser.username).to.equal('root')
-    expect(rootUser.email).to.equal('admin1@example.com')
-    expect(user.nsfwPolicy).to.equal('display')
+    it('Should have video quota updated', async function () {
+      const res = await getMyUserVideoQuotaUsed(server.url, accessTokenUser)
+      const data = res.body
 
-    userId = user.id
-  })
+      expect(data.videoQuotaUsed).to.equal(218910)
 
-  it('Should list only the first user by username asc', async function () {
-    const res = await getUsersListPaginationAndSort(server.url, server.accessToken, 0, 1, 'username')
+      const resUsers = await getUsersList(server.url, server.accessToken)
 
-    const result = res.body
-    const total = result.total
-    const users = result.data
+      const users: User[] = resUsers.body.data
+      const tmpUser = users.find(u => u.username === user.username)
+      expect(tmpUser.videoQuotaUsed).to.equal(218910)
+    })
 
-    expect(total).to.equal(2)
-    expect(users.length).to.equal(1)
+    it('Should be able to list my videos', async function () {
+      const res = await getMyVideos(server.url, accessTokenUser, 0, 5)
+      expect(res.body.total).to.equal(1)
+
+      const videos = res.body.data
+      expect(videos).to.have.lengthOf(1)
 
-    const user = users[ 0 ]
-    expect(user.username).to.equal('root')
-    expect(user.email).to.equal('admin1@example.com')
-    expect(user.roleLabel).to.equal('Administrator')
-    expect(user.nsfwPolicy).to.equal('display')
+      const video: Video = videos[ 0 ]
+      expect(video.name).to.equal('super user video')
+      expect(video.thumbnailPath).to.not.be.null
+      expect(video.previewPath).to.not.be.null
+    })
   })
 
-  it('Should list only the first user by username desc', async function () {
-    const res = await getUsersListPaginationAndSort(server.url, server.accessToken, 0, 1, '-username')
-    const result = res.body
-    const total = result.total
-    const users = result.data
+  describe('Users listing', function () {
 
-    expect(total).to.equal(2)
-    expect(users.length).to.equal(1)
+    it('Should list all the users', async function () {
+      const res = await getUsersList(server.url, server.accessToken)
+      const result = res.body
+      const total = result.total
+      const users = result.data
 
-    const user = users[ 0 ]
-    expect(user.username).to.equal('user_1')
-    expect(user.email).to.equal('user_1@example.com')
-    expect(user.nsfwPolicy).to.equal('display')
-  })
+      expect(total).to.equal(2)
+      expect(users).to.be.an('array')
+      expect(users.length).to.equal(2)
 
-  it('Should list only the second user by createdAt desc', async function () {
-    const res = await getUsersListPaginationAndSort(server.url, server.accessToken, 0, 1, '-createdAt')
-    const result = res.body
-    const total = result.total
-    const users = result.data
+      const user = users[ 0 ]
+      expect(user.username).to.equal('user_1')
+      expect(user.email).to.equal('user_1@example.com')
+      expect(user.nsfwPolicy).to.equal('display')
 
-    expect(total).to.equal(2)
-    expect(users.length).to.equal(1)
+      const rootUser = users[ 1 ]
+      expect(rootUser.username).to.equal('root')
+      expect(rootUser.email).to.equal('admin1@example.com')
+      expect(user.nsfwPolicy).to.equal('display')
 
-    const user = users[ 0 ]
-    expect(user.username).to.equal('user_1')
-    expect(user.email).to.equal('user_1@example.com')
-    expect(user.nsfwPolicy).to.equal('display')
-  })
+      userId = user.id
+    })
 
-  it('Should list all the users by createdAt asc', async function () {
-    const res = await getUsersListPaginationAndSort(server.url, server.accessToken, 0, 2, 'createdAt')
-    const result = res.body
-    const total = result.total
-    const users = result.data
+    it('Should list only the first user by username asc', async function () {
+      const res = await getUsersListPaginationAndSort(server.url, server.accessToken, 0, 1, 'username')
 
-    expect(total).to.equal(2)
-    expect(users.length).to.equal(2)
+      const result = res.body
+      const total = result.total
+      const users = result.data
 
-    expect(users[ 0 ].username).to.equal('root')
-    expect(users[ 0 ].email).to.equal('admin1@example.com')
-    expect(users[ 0 ].nsfwPolicy).to.equal('display')
+      expect(total).to.equal(2)
+      expect(users.length).to.equal(1)
 
-    expect(users[ 1 ].username).to.equal('user_1')
-    expect(users[ 1 ].email).to.equal('user_1@example.com')
-    expect(users[ 1 ].nsfwPolicy).to.equal('display')
-  })
+      const user = users[ 0 ]
+      expect(user.username).to.equal('root')
+      expect(user.email).to.equal('admin1@example.com')
+      expect(user.roleLabel).to.equal('Administrator')
+      expect(user.nsfwPolicy).to.equal('display')
+    })
 
-  it('Should search user by username', async function () {
-    const res = await getUsersListPaginationAndSort(server.url, server.accessToken, 0, 2, 'createdAt', 'oot')
-    const users = res.body.data as User[]
+    it('Should list only the first user by username desc', async function () {
+      const res = await getUsersListPaginationAndSort(server.url, server.accessToken, 0, 1, '-username')
+      const result = res.body
+      const total = result.total
+      const users = result.data
 
-    expect(res.body.total).to.equal(1)
-    expect(users.length).to.equal(1)
+      expect(total).to.equal(2)
+      expect(users.length).to.equal(1)
 
-    expect(users[ 0 ].username).to.equal('root')
-  })
+      const user = users[ 0 ]
+      expect(user.username).to.equal('user_1')
+      expect(user.email).to.equal('user_1@example.com')
+      expect(user.nsfwPolicy).to.equal('display')
+    })
 
-  it('Should search user by email', async function () {
-    {
-      const res = await getUsersListPaginationAndSort(server.url, server.accessToken, 0, 2, 'createdAt', 'r_1@exam')
-      const users = res.body.data as User[]
+    it('Should list only the second user by createdAt desc', async function () {
+      const res = await getUsersListPaginationAndSort(server.url, server.accessToken, 0, 1, '-createdAt')
+      const result = res.body
+      const total = result.total
+      const users = result.data
 
-      expect(res.body.total).to.equal(1)
+      expect(total).to.equal(2)
       expect(users.length).to.equal(1)
 
-      expect(users[ 0 ].username).to.equal('user_1')
-      expect(users[ 0 ].email).to.equal('user_1@example.com')
-    }
+      const user = users[ 0 ]
+      expect(user.username).to.equal('user_1')
+      expect(user.email).to.equal('user_1@example.com')
+      expect(user.nsfwPolicy).to.equal('display')
+    })
 
-    {
-      const res = await getUsersListPaginationAndSort(server.url, server.accessToken, 0, 2, 'createdAt', 'example')
-      const users = res.body.data as User[]
+    it('Should list all the users by createdAt asc', async function () {
+      const res = await getUsersListPaginationAndSort(server.url, server.accessToken, 0, 2, 'createdAt')
+      const result = res.body
+      const total = result.total
+      const users = result.data
 
-      expect(res.body.total).to.equal(2)
+      expect(total).to.equal(2)
       expect(users.length).to.equal(2)
 
       expect(users[ 0 ].username).to.equal('root')
-      expect(users[ 1 ].username).to.equal('user_1')
-    }
-  })
+      expect(users[ 0 ].email).to.equal('admin1@example.com')
+      expect(users[ 0 ].nsfwPolicy).to.equal('display')
 
-  it('Should update my password', async function () {
-    await updateMyUser({
-      url: server.url,
-      accessToken: accessTokenUser,
-      currentPassword: 'super password',
-      newPassword: 'new password'
+      expect(users[ 1 ].username).to.equal('user_1')
+      expect(users[ 1 ].email).to.equal('user_1@example.com')
+      expect(users[ 1 ].nsfwPolicy).to.equal('display')
     })
-    user.password = 'new password'
 
-    await userLogin(server, user, 200)
-  })
+    it('Should search user by username', async function () {
+      const res = await getUsersListPaginationAndSort(server.url, server.accessToken, 0, 2, 'createdAt', 'oot')
+      const users = res.body.data as User[]
+
+      expect(res.body.total).to.equal(1)
+      expect(users.length).to.equal(1)
 
-  it('Should be able to change the NSFW display attribute', async function () {
-    await updateMyUser({
-      url: server.url,
-      accessToken: accessTokenUser,
-      nsfwPolicy: 'do_not_list'
+      expect(users[ 0 ].username).to.equal('root')
     })
 
-    const res = await getMyUserInformation(server.url, accessTokenUser)
-    const user = res.body
+    it('Should search user by email', async function () {
+      {
+        const res = await getUsersListPaginationAndSort(server.url, server.accessToken, 0, 2, 'createdAt', 'r_1@exam')
+        const users = res.body.data as User[]
 
-    expect(user.username).to.equal('user_1')
-    expect(user.email).to.equal('user_1@example.com')
-    expect(user.nsfwPolicy).to.equal('do_not_list')
-    expect(user.videoQuota).to.equal(2 * 1024 * 1024)
-    expect(user.id).to.be.a('number')
-    expect(user.account.displayName).to.equal('user_1')
-    expect(user.account.description).to.be.null
-  })
+        expect(res.body.total).to.equal(1)
+        expect(users.length).to.equal(1)
 
-  it('Should be able to change the autoPlayVideo attribute', async function () {
-    await updateMyUser({
-      url: server.url,
-      accessToken: accessTokenUser,
-      autoPlayVideo: false
-    })
+        expect(users[ 0 ].username).to.equal('user_1')
+        expect(users[ 0 ].email).to.equal('user_1@example.com')
+      }
 
-    const res = await getMyUserInformation(server.url, accessTokenUser)
-    const user = res.body
+      {
+        const res = await getUsersListPaginationAndSort(server.url, server.accessToken, 0, 2, 'createdAt', 'example')
+        const users = res.body.data as User[]
 
-    expect(user.autoPlayVideo).to.be.false
+        expect(res.body.total).to.equal(2)
+        expect(users.length).to.equal(2)
+
+        expect(users[ 0 ].username).to.equal('root')
+        expect(users[ 1 ].username).to.equal('user_1')
+      }
+    })
   })
 
-  it('Should be able to change the email display attribute', async function () {
-    await updateMyUser({
-      url: server.url,
-      accessToken: accessTokenUser,
-      email: 'updated@example.com'
+  describe('Update my account', function () {
+    it('Should update my password', async function () {
+      await updateMyUser({
+        url: server.url,
+        accessToken: accessTokenUser,
+        currentPassword: 'super password',
+        newPassword: 'new password'
+      })
+      user.password = 'new password'
+
+      await userLogin(server, user, 200)
     })
 
-    const res = await getMyUserInformation(server.url, accessTokenUser)
-    const user = res.body
+    it('Should be able to change the NSFW display attribute', async function () {
+      await updateMyUser({
+        url: server.url,
+        accessToken: accessTokenUser,
+        nsfwPolicy: 'do_not_list'
+      })
+
+      const res = await getMyUserInformation(server.url, accessTokenUser)
+      const user = res.body
+
+      expect(user.username).to.equal('user_1')
+      expect(user.email).to.equal('user_1@example.com')
+      expect(user.nsfwPolicy).to.equal('do_not_list')
+      expect(user.videoQuota).to.equal(2 * 1024 * 1024)
+      expect(user.id).to.be.a('number')
+      expect(user.account.displayName).to.equal('user_1')
+      expect(user.account.description).to.be.null
+    })
 
-    expect(user.username).to.equal('user_1')
-    expect(user.email).to.equal('updated@example.com')
-    expect(user.nsfwPolicy).to.equal('do_not_list')
-    expect(user.videoQuota).to.equal(2 * 1024 * 1024)
-    expect(user.id).to.be.a('number')
-    expect(user.account.displayName).to.equal('user_1')
-    expect(user.account.description).to.be.null
-  })
+    it('Should be able to change the autoPlayVideo attribute', async function () {
+      await updateMyUser({
+        url: server.url,
+        accessToken: accessTokenUser,
+        autoPlayVideo: false
+      })
+
+      const res = await getMyUserInformation(server.url, accessTokenUser)
+      const user = res.body
 
-  it('Should be able to update my avatar', async function () {
-    const fixture = 'avatar.png'
+      expect(user.autoPlayVideo).to.be.false
+    })
 
-    await updateMyAvatar({
-      url: server.url,
-      accessToken: accessTokenUser,
-      fixture
+    it('Should be able to change the email display attribute', async function () {
+      await updateMyUser({
+        url: server.url,
+        accessToken: accessTokenUser,
+        email: 'updated@example.com'
+      })
+
+      const res = await getMyUserInformation(server.url, accessTokenUser)
+      const user = res.body
+
+      expect(user.username).to.equal('user_1')
+      expect(user.email).to.equal('updated@example.com')
+      expect(user.nsfwPolicy).to.equal('do_not_list')
+      expect(user.videoQuota).to.equal(2 * 1024 * 1024)
+      expect(user.id).to.be.a('number')
+      expect(user.account.displayName).to.equal('user_1')
+      expect(user.account.description).to.be.null
     })
 
-    const res = await getMyUserInformation(server.url, accessTokenUser)
-    const user = res.body
+    it('Should be able to update my avatar', async function () {
+      const fixture = 'avatar.png'
 
-    await testImage(server.url, 'avatar-resized', user.account.avatar.path, '.png')
-  })
+      await updateMyAvatar({
+        url: server.url,
+        accessToken: accessTokenUser,
+        fixture
+      })
+
+      const res = await getMyUserInformation(server.url, accessTokenUser)
+      const user = res.body
 
-  it('Should be able to update my display name', async function () {
-    await updateMyUser({
-      url: server.url,
-      accessToken: accessTokenUser,
-      displayName: 'new display name'
+      await testImage(server.url, 'avatar-resized', user.account.avatar.path, '.png')
     })
 
-    const res = await getMyUserInformation(server.url, accessTokenUser)
-    const user = res.body
+    it('Should be able to update my display name', async function () {
+      await updateMyUser({
+        url: server.url,
+        accessToken: accessTokenUser,
+        displayName: 'new display name'
+      })
+
+      const res = await getMyUserInformation(server.url, accessTokenUser)
+      const user = res.body
+
+      expect(user.username).to.equal('user_1')
+      expect(user.email).to.equal('updated@example.com')
+      expect(user.nsfwPolicy).to.equal('do_not_list')
+      expect(user.videoQuota).to.equal(2 * 1024 * 1024)
+      expect(user.id).to.be.a('number')
+      expect(user.account.displayName).to.equal('new display name')
+      expect(user.account.description).to.be.null
+    })
 
-    expect(user.username).to.equal('user_1')
-    expect(user.email).to.equal('updated@example.com')
-    expect(user.nsfwPolicy).to.equal('do_not_list')
-    expect(user.videoQuota).to.equal(2 * 1024 * 1024)
-    expect(user.id).to.be.a('number')
-    expect(user.account.displayName).to.equal('new display name')
-    expect(user.account.description).to.be.null
+    it('Should be able to update my description', async function () {
+      await updateMyUser({
+        url: server.url,
+        accessToken: accessTokenUser,
+        description: 'my super description updated'
+      })
+
+      const res = await getMyUserInformation(server.url, accessTokenUser)
+      const user = res.body
+
+      expect(user.username).to.equal('user_1')
+      expect(user.email).to.equal('updated@example.com')
+      expect(user.nsfwPolicy).to.equal('do_not_list')
+      expect(user.videoQuota).to.equal(2 * 1024 * 1024)
+      expect(user.id).to.be.a('number')
+      expect(user.account.displayName).to.equal('new display name')
+      expect(user.account.description).to.equal('my super description updated')
+    })
   })
 
-  it('Should be able to update my description', async function () {
-    await updateMyUser({
-      url: server.url,
-      accessToken: accessTokenUser,
-      description: 'my super description updated'
+  describe('Updating another user', function () {
+
+    it('Should be able to update another user', async function () {
+      await updateUser({
+        url: server.url,
+        userId,
+        accessToken,
+        email: 'updated2@example.com',
+        emailVerified: true,
+        videoQuota: 42,
+        role: UserRole.MODERATOR,
+        adminFlags: UserAdminFlag.NONE
+      })
+
+      const res = await getUserInformation(server.url, accessToken, userId)
+      const user = res.body
+
+      expect(user.username).to.equal('user_1')
+      expect(user.email).to.equal('updated2@example.com')
+      expect(user.emailVerified).to.be.true
+      expect(user.nsfwPolicy).to.equal('do_not_list')
+      expect(user.videoQuota).to.equal(42)
+      expect(user.roleLabel).to.equal('Moderator')
+      expect(user.id).to.be.a('number')
+      expect(user.adminFlags).to.equal(UserAdminFlag.NONE)
     })
 
-    const res = await getMyUserInformation(server.url, accessTokenUser)
-    const user = res.body
+    it('Should have removed the user token', async function () {
+      await getMyUserVideoQuotaUsed(server.url, accessTokenUser, 401)
 
-    expect(user.username).to.equal('user_1')
-    expect(user.email).to.equal('updated@example.com')
-    expect(user.nsfwPolicy).to.equal('do_not_list')
-    expect(user.videoQuota).to.equal(2 * 1024 * 1024)
-    expect(user.id).to.be.a('number')
-    expect(user.account.displayName).to.equal('new display name')
-    expect(user.account.description).to.equal('my super description updated')
-  })
+      accessTokenUser = await userLogin(server, user)
+    })
 
-  it('Should be able to update another user', async function () {
-    await updateUser({
-      url: server.url,
-      userId,
-      accessToken,
-      email: 'updated2@example.com',
-      emailVerified: true,
-      videoQuota: 42,
-      role: UserRole.MODERATOR
-    })
-
-    const res = await getUserInformation(server.url, accessToken, userId)
-    const user = res.body
-
-    expect(user.username).to.equal('user_1')
-    expect(user.email).to.equal('updated2@example.com')
-    expect(user.emailVerified).to.be.true
-    expect(user.nsfwPolicy).to.equal('do_not_list')
-    expect(user.videoQuota).to.equal(42)
-    expect(user.roleLabel).to.equal('Moderator')
-    expect(user.id).to.be.a('number')
-  })
+    it('Should be able to update another user password', async function () {
+      await updateUser({
+        url: server.url,
+        userId,
+        accessToken,
+        password: 'password updated'
+      })
 
-  it('Should have removed the user token', async function () {
-    await getMyUserVideoQuotaUsed(server.url, accessTokenUser, 401)
+      await getMyUserVideoQuotaUsed(server.url, accessTokenUser, 401)
 
-    accessTokenUser = await userLogin(server, user)
-  })
+      await userLogin(server, user, 400)
 
-  it('Should be able to list video blacklist by a moderator', async function () {
-    await getBlacklistedVideosList(server.url, accessTokenUser)
+      user.password = 'password updated'
+      accessTokenUser = await userLogin(server, user)
+    })
   })
 
-  it('Should be able to remove this user', async function () {
-    await removeUser(server.url, userId, accessToken)
+  describe('Video blacklists', function () {
+    it('Should be able to list video blacklist by a moderator', async function () {
+      await getBlacklistedVideosList({ url: server.url, token: accessTokenUser })
+    })
   })
 
-  it('Should not be able to login with this user', async function () {
-    await userLogin(server, user, 400)
-  })
+  describe('Remove a user', function () {
+    it('Should be able to remove this user', async function () {
+      await removeUser(server.url, userId, accessToken)
+    })
 
-  it('Should not have videos of this user', async function () {
-    const res = await getVideosList(server.url)
+    it('Should not be able to login with this user', async function () {
+      await userLogin(server, user, 400)
+    })
 
-    expect(res.body.total).to.equal(1)
+    it('Should not have videos of this user', async function () {
+      const res = await getVideosList(server.url)
 
-    const video = res.body.data[ 0 ]
-    expect(video.account.name).to.equal('root')
-  })
+      expect(res.body.total).to.equal(1)
 
-  it('Should register a new user', async function () {
-    await registerUser(server.url, 'user_15', 'my super password')
+      const video = res.body.data[ 0 ]
+      expect(video.account.name).to.equal('root')
+    })
   })
 
-  it('Should be able to login with this registered user', async function () {
-    const user15 = {
-      username: 'user_15',
-      password: 'my super password'
-    }
+  describe('Registering a new user', function () {
+    it('Should register a new user', async function () {
+      await registerUser(server.url, 'user_15', 'my super password')
+    })
 
-    accessToken = await userLogin(server, user15)
-  })
+    it('Should be able to login with this registered user', async function () {
+      const user15 = {
+        username: 'user_15',
+        password: 'my super password'
+      }
 
-  it('Should have the correct video quota', async function () {
-    const res = await getMyUserInformation(server.url, accessToken)
-    const user = res.body
+      accessToken = await userLogin(server, user15)
+    })
 
-    expect(user.videoQuota).to.equal(5 * 1024 * 1024)
-  })
+    it('Should have the correct video quota', async function () {
+      const res = await getMyUserInformation(server.url, accessToken)
+      const user = res.body
 
-  it('Should remove me', async function () {
-    {
-      const res = await getUsersList(server.url, server.accessToken)
-      expect(res.body.data.find(u => u.username === 'user_15')).to.not.be.undefined
-    }
+      expect(user.videoQuota).to.equal(5 * 1024 * 1024)
+    })
 
-    await deleteMe(server.url, accessToken)
+    it('Should remove me', async function () {
+      {
+        const res = await getUsersList(server.url, server.accessToken)
+        expect(res.body.data.find(u => u.username === 'user_15')).to.not.be.undefined
+      }
 
-    {
-      const res = await getUsersList(server.url, server.accessToken)
-      expect(res.body.data.find(u => u.username === 'user_15')).to.be.undefined
-    }
+      await deleteMe(server.url, accessToken)
+
+      {
+        const res = await getUsersList(server.url, server.accessToken)
+        expect(res.body.data.find(u => u.username === 'user_15')).to.be.undefined
+      }
+    })
   })
 
-  it('Should block and unblock a user', async function () {
-    const user16 = {
-      username: 'user_16',
-      password: 'my super password'
-    }
-    const resUser = await createUser(server.url, server.accessToken, user16.username, user16.password)
-    const user16Id = resUser.body.user.id
+  describe('User blocking', function () {
+    it('Should block and unblock a user', async function () {
+      const user16 = {
+        username: 'user_16',
+        password: 'my super password'
+      }
+      const resUser = await createUser({
+        url: server.url,
+        accessToken: server.accessToken,
+        username: user16.username,
+        password: user16.password
+      })
+      const user16Id = resUser.body.user.id
 
-    accessToken = await userLogin(server, user16)
+      accessToken = await userLogin(server, user16)
 
-    await getMyUserInformation(server.url, accessToken, 200)
-    await blockUser(server.url, user16Id, server.accessToken)
+      await getMyUserInformation(server.url, accessToken, 200)
+      await blockUser(server.url, user16Id, server.accessToken)
 
-    await getMyUserInformation(server.url, accessToken, 401)
-    await userLogin(server, user16, 400)
+      await getMyUserInformation(server.url, accessToken, 401)
+      await userLogin(server, user16, 400)
 
-    await unblockUser(server.url, user16Id, server.accessToken)
-    accessToken = await userLogin(server, user16)
-    await getMyUserInformation(server.url, accessToken, 200)
+      await unblockUser(server.url, user16Id, server.accessToken)
+      accessToken = await userLogin(server, user16)
+      await getMyUserInformation(server.url, accessToken, 200)
+    })
   })
 
   after(async function () {
-    killallServers([ server ])
-
-    // Keep the logs if the test failed
-    if (this[ 'ok' ]) {
-      await flushTests()
-    }
+    await cleanupTests([ server ])
   })
 })
diff --git a/server/tests/api/videos/index.ts b/server/tests/api/videos/index.ts
index 97f467aae..93e1f3e98 100644
--- a/server/tests/api/videos/index.ts
+++ b/server/tests/api/videos/index.ts
@@ -8,11 +8,14 @@ import './video-change-ownership'
 import './video-channels'
 import './video-comments'
 import './video-description'
+import './video-hls'
 import './video-imports'
 import './video-nsfw'
+import './video-playlists'
 import './video-privacy'
 import './video-schedule-update'
 import './video-transcoder'
 import './videos-filter'
 import './videos-history'
 import './videos-overview'
+import './videos-views-cleaner'
diff --git a/server/tests/api/videos/multiple-servers.ts b/server/tests/api/videos/multiple-servers.ts
index 6c281e49e..68c1e9a8d 100644
--- a/server/tests/api/videos/multiple-servers.ts
+++ b/server/tests/api/videos/multiple-servers.ts
@@ -9,7 +9,7 @@ import { VideoComment, VideoCommentThreadTree } from '../../../../shared/models/
 import {
   addVideoChannel,
   checkTmpIsEmpty,
-  checkVideoFilesWereRemoved,
+  checkVideoFilesWereRemoved, cleanupTests,
   completeVideoCheck,
   createUser,
   dateIsValid,
@@ -32,15 +32,15 @@ import {
   viewVideo,
   wait,
   webtorrentAdd
-} from '../../../../shared/utils'
+} from '../../../../shared/extra-utils'
 import {
   addVideoCommentReply,
   addVideoCommentThread,
   deleteVideoComment,
   getVideoCommentThreads,
   getVideoThreadComments
-} from '../../../../shared/utils/videos/video-comments'
-import { waitJobs } from '../../../../shared/utils/server/jobs'
+} from '../../../../shared/extra-utils/videos/video-comments'
+import { waitJobs } from '../../../../shared/extra-utils/server/jobs'
 
 const expect = chai.expect
 
@@ -98,6 +98,7 @@ describe('Test multiple servers', function () {
         nsfw: true,
         description: 'my super description for server 1',
         support: 'my super support text for server 1',
+        originallyPublishedAt: '2019-02-10T13:38:14.449Z',
         tags: [ 'tag1p1', 'tag2p1' ],
         channelId: videoChannelId,
         fixture: 'video_short1.webm'
@@ -118,6 +119,7 @@ describe('Test multiple servers', function () {
           nsfw: true,
           description: 'my super description for server 1',
           support: 'my super support text for server 1',
+          originallyPublishedAt: '2019-02-10T13:38:14.449Z',
           account: {
             name: 'root',
             host: 'localhost:9001'
@@ -128,6 +130,7 @@ describe('Test multiple servers', function () {
           tags: [ 'tag1p1', 'tag2p1' ],
           privacy: VideoPrivacy.PUBLIC,
           commentsEnabled: true,
+          downloadEnabled: true,
           channel: {
             displayName: 'my channel',
             name: 'super_channel_name',
@@ -161,7 +164,7 @@ describe('Test multiple servers', function () {
         username: 'user1',
         password: 'super_password'
       }
-      await createUser(servers[1].url, servers[1].accessToken, user.username, user.password)
+      await createUser({ url: servers[ 1 ].url, accessToken: servers[ 1 ].accessToken, username: user.username, password: user.password })
       const userAccessToken = await userLogin(servers[1], user)
 
       const videoAttributes = {
@@ -199,6 +202,7 @@ describe('Test multiple servers', function () {
           },
           isLocal,
           commentsEnabled: true,
+          downloadEnabled: true,
           duration: 5,
           tags: [ 'tag1p2', 'tag2p2', 'tag3p2' ],
           privacy: VideoPrivacy.PUBLIC,
@@ -307,6 +311,7 @@ describe('Test multiple servers', function () {
           isLocal,
           duration: 5,
           commentsEnabled: true,
+          downloadEnabled: true,
           tags: [ 'tag1p3' ],
           privacy: VideoPrivacy.PUBLIC,
           channel: {
@@ -338,6 +343,7 @@ describe('Test multiple servers', function () {
             host: 'localhost:9003'
           },
           commentsEnabled: true,
+          downloadEnabled: true,
           isLocal,
           duration: 5,
           tags: [ 'tag2p3', 'tag3p3', 'tag4p3' ],
@@ -573,15 +579,15 @@ describe('Test multiple servers', function () {
       this.timeout(20000)
 
       await rateVideo(servers[0].url, servers[0].accessToken, remoteVideosServer1[0], 'like')
-      await wait(200)
+      await wait(500)
       await rateVideo(servers[0].url, servers[0].accessToken, remoteVideosServer1[0], 'dislike')
-      await wait(200)
+      await wait(500)
       await rateVideo(servers[0].url, servers[0].accessToken, remoteVideosServer1[0], 'like')
       await rateVideo(servers[2].url, servers[2].accessToken, localVideosServer3[1], 'like')
-      await wait(200)
+      await wait(500)
       await rateVideo(servers[2].url, servers[2].accessToken, localVideosServer3[1], 'dislike')
       await rateVideo(servers[2].url, servers[2].accessToken, remoteVideosServer3[1], 'dislike')
-      await wait(200)
+      await wait(500)
       await rateVideo(servers[2].url, servers[2].accessToken, remoteVideosServer3[0], 'like')
 
       await waitJobs(servers)
@@ -621,6 +627,7 @@ describe('Test multiple servers', function () {
         support: 'my super support text updated',
         tags: [ 'tag_up_1', 'tag_up_2' ],
         thumbnailfile: 'thumbnail.jpg',
+        originallyPublishedAt: '2019-02-11T13:38:14.449Z',
         previewfile: 'preview.jpg'
       }
 
@@ -648,6 +655,7 @@ describe('Test multiple servers', function () {
           nsfw: true,
           description: 'my super description updated',
           support: 'my super support text updated',
+          originallyPublishedAt: '2019-02-11T13:38:14.449Z',
           account: {
             name: 'root',
             host: 'localhost:9003'
@@ -655,6 +663,7 @@ describe('Test multiple servers', function () {
           isLocal,
           duration: 5,
           commentsEnabled: true,
+          downloadEnabled: true,
           tags: [ 'tag_up_1', 'tag_up_2' ],
           privacy: VideoPrivacy.PUBLIC,
           channel: {
@@ -914,11 +923,12 @@ describe('Test multiple servers', function () {
       }
     })
 
-    it('Should disable comments', async function () {
+    it('Should disable comments and download', async function () {
       this.timeout(20000)
 
       const attributes = {
-        commentsEnabled: false
+        commentsEnabled: false,
+        downloadEnabled: false
       }
 
       await updateVideo(servers[0].url, servers[0].accessToken, videoUUID, attributes)
@@ -928,6 +938,7 @@ describe('Test multiple servers', function () {
       for (const server of servers) {
         const res = await getVideo(server.url, videoUUID)
         expect(res.body.commentsEnabled).to.be.false
+        expect(res.body.downloadEnabled).to.be.false
 
         const text = 'my super forbidden comment'
         await addVideoCommentThread(server.url, server.accessToken, videoUUID, text, 409)
@@ -976,6 +987,7 @@ describe('Test multiple servers', function () {
           isLocal,
           duration: 5,
           commentsEnabled: false,
+          downloadEnabled: true,
           tags: [ ],
           privacy: VideoPrivacy.PUBLIC,
           channel: {
@@ -1018,11 +1030,6 @@ describe('Test multiple servers', function () {
   })
 
   after(async function () {
-    killallServers(servers)
-
-    // Keep the logs if the test failed
-    if (this['ok']) {
-      await flushTests()
-    }
+    await cleanupTests(servers)
   })
 })
diff --git a/server/tests/api/videos/services.ts b/server/tests/api/videos/services.ts
index 2da86964f..e9ad947b2 100644
--- a/server/tests/api/videos/services.ts
+++ b/server/tests/api/videos/services.ts
@@ -2,16 +2,8 @@
 
 import * as chai from 'chai'
 import 'mocha'
-import {
-  flushTests,
-  getOEmbed,
-  getVideosList,
-  killallServers,
-  ServerInfo,
-  setAccessTokensToServers,
-  uploadVideo
-} from '../../../../shared/utils/index'
-import { runServer } from '../../../../shared/utils/server/servers'
+import { getOEmbed, getVideosList, ServerInfo, setAccessTokensToServers, uploadVideo } from '../../../../shared/extra-utils/index'
+import { cleanupTests, flushAndRunServer } from '../../../../shared/extra-utils/server/servers'
 
 const expect = chai.expect
 
@@ -21,9 +13,7 @@ describe('Test services', function () {
   before(async function () {
     this.timeout(30000)
 
-    await flushTests()
-
-    server = await runServer(1)
+    server = await flushAndRunServer(1)
 
     await setAccessTokensToServers([ server ])
 
@@ -77,6 +67,6 @@ describe('Test services', function () {
   })
 
   after(async function () {
-    killallServers([ server ])
+    await cleanupTests([ server ])
   })
 })
diff --git a/server/tests/api/videos/single-server.ts b/server/tests/api/videos/single-server.ts
index 069dec67c..1f366b642 100644
--- a/server/tests/api/videos/single-server.ts
+++ b/server/tests/api/videos/single-server.ts
@@ -6,8 +6,9 @@ import 'mocha'
 import { VideoPrivacy } from '../../../../shared/models/videos'
 import {
   checkVideoFilesWereRemoved,
+  cleanupTests,
   completeVideoCheck,
-  flushTests,
+  flushAndRunServer,
   getVideo,
   getVideoCategories,
   getVideoLanguages,
@@ -17,10 +18,8 @@ import {
   getVideosListPagination,
   getVideosListSort,
   getVideosWithFilters,
-  killallServers,
   rateVideo,
   removeVideo,
-  runServer,
   ServerInfo,
   setAccessTokensToServers,
   testImage,
@@ -28,7 +27,7 @@ import {
   uploadVideo,
   viewVideo,
   wait
-} from '../../../../shared/utils'
+} from '../../../../shared/extra-utils'
 
 const expect = chai.expect
 
@@ -55,6 +54,7 @@ describe('Test a single server', function () {
     tags: [ 'tag1', 'tag2', 'tag3' ],
     privacy: VideoPrivacy.PUBLIC,
     commentsEnabled: true,
+    downloadEnabled: true,
     channel: {
       displayName: 'Main root channel',
       name: 'root_channel',
@@ -87,6 +87,7 @@ describe('Test a single server', function () {
     privacy: VideoPrivacy.PUBLIC,
     duration: 5,
     commentsEnabled: false,
+    downloadEnabled: false,
     channel: {
       name: 'root_channel',
       displayName: 'Main root channel',
@@ -105,9 +106,7 @@ describe('Test a single server', function () {
   before(async function () {
     this.timeout(30000)
 
-    await flushTests()
-
-    server = await runServer(1)
+    server = await flushAndRunServer(1)
 
     await setAccessTokensToServers([ server ])
   })
@@ -356,6 +355,7 @@ describe('Test a single server', function () {
       nsfw: false,
       description: 'my super description updated',
       commentsEnabled: false,
+      downloadEnabled: false,
       tags: [ 'tagup1', 'tagup2' ]
     }
     await updateVideo(server.url, server.accessToken, videoId, attributes)
@@ -424,11 +424,6 @@ describe('Test a single server', function () {
   })
 
   after(async function () {
-    killallServers([ server ])
-
-    // Keep the logs if the test failed
-    if (this['ok']) {
-      await flushTests()
-    }
+    await cleanupTests([ server ])
   })
 })
diff --git a/server/tests/api/videos/video-abuse.ts b/server/tests/api/videos/video-abuse.ts
index 3a7b623da..7318497d5 100644
--- a/server/tests/api/videos/video-abuse.ts
+++ b/server/tests/api/videos/video-abuse.ts
@@ -4,6 +4,7 @@ import * as chai from 'chai'
 import 'mocha'
 import { VideoAbuse, VideoAbuseState } from '../../../../shared/models/videos'
 import {
+  cleanupTests,
   deleteVideoAbuse,
   flushAndRunMultipleServers,
   getVideoAbusesList,
@@ -14,9 +15,9 @@ import {
   setAccessTokensToServers,
   updateVideoAbuse,
   uploadVideo
-} from '../../../../shared/utils/index'
-import { doubleFollow } from '../../../../shared/utils/server/follows'
-import { waitJobs } from '../../../../shared/utils/server/jobs'
+} from '../../../../shared/extra-utils/index'
+import { doubleFollow } from '../../../../shared/extra-utils/server/follows'
+import { waitJobs } from '../../../../shared/extra-utils/server/jobs'
 
 const expect = chai.expect
 
@@ -173,6 +174,6 @@ describe('Test video abuses', function () {
   })
 
   after(async function () {
-    killallServers(servers)
+    await cleanupTests(servers)
   })
 })
diff --git a/server/tests/api/videos/video-blacklist.ts b/server/tests/api/videos/video-blacklist.ts
index d39ad63b4..e907bbdc0 100644
--- a/server/tests/api/videos/video-blacklist.ts
+++ b/server/tests/api/videos/video-blacklist.ts
@@ -4,29 +4,32 @@ import * as chai from 'chai'
 import { orderBy } from 'lodash'
 import 'mocha'
 import {
-  addVideoToBlacklist,
+  addVideoToBlacklist, cleanupTests,
+  createUser,
   flushAndRunMultipleServers,
   getBlacklistedVideosList,
   getMyVideos,
-  getSortedBlacklistedVideosList,
   getVideosList,
   killallServers,
   removeVideoFromBlacklist,
+  reRunServer,
   searchVideo,
   ServerInfo,
   setAccessTokensToServers,
   updateVideo,
   updateVideoBlacklist,
   uploadVideo,
-  viewVideo
-} from '../../../../shared/utils/index'
-import { doubleFollow } from '../../../../shared/utils/server/follows'
-import { waitJobs } from '../../../../shared/utils/server/jobs'
-import { VideoBlacklist } from '../../../../shared/models/videos'
+  userLogin
+} from '../../../../shared/extra-utils/index'
+import { doubleFollow } from '../../../../shared/extra-utils/server/follows'
+import { waitJobs } from '../../../../shared/extra-utils/server/jobs'
+import { VideoBlacklist, VideoBlacklistType } from '../../../../shared/models/videos'
+import { UserAdminFlag } from '../../../../shared/models/users/user-flag.model'
+import { UserRole } from '../../../../shared/models/users'
 
 const expect = chai.expect
 
-describe('Test video blacklist management', function () {
+describe('Test video blacklist', function () {
   let servers: ServerInfo[] = []
   let videoId: number
 
@@ -101,9 +104,9 @@ describe('Test video blacklist management', function () {
     })
   })
 
-  describe('When listing blacklisted videos', function () {
+  describe('When listing manually blacklisted videos', function () {
     it('Should display all the blacklisted videos', async function () {
-      const res = await getBlacklistedVideosList(servers[0].url, servers[0].accessToken)
+      const res = await getBlacklistedVideosList({ url: servers[0].url, token: servers[0].accessToken })
 
       expect(res.body.total).to.equal(2)
 
@@ -117,8 +120,36 @@ describe('Test video blacklist management', function () {
       }
     })
 
+    it('Should display all the blacklisted videos when applying manual type filter', async function () {
+      const res = await getBlacklistedVideosList({
+        url: servers[ 0 ].url,
+        token: servers[ 0 ].accessToken,
+        type: VideoBlacklistType.MANUAL
+      })
+
+      expect(res.body.total).to.equal(2)
+
+      const blacklistedVideos = res.body.data
+      expect(blacklistedVideos).to.be.an('array')
+      expect(blacklistedVideos.length).to.equal(2)
+    })
+
+    it('Should display nothing when applying automatic type filter', async function () {
+      const res = await getBlacklistedVideosList({
+        url: servers[ 0 ].url,
+        token: servers[ 0 ].accessToken,
+        type: VideoBlacklistType.AUTO_BEFORE_PUBLISHED
+      })
+
+      expect(res.body.total).to.equal(0)
+
+      const blacklistedVideos = res.body.data
+      expect(blacklistedVideos).to.be.an('array')
+      expect(blacklistedVideos.length).to.equal(0)
+    })
+
     it('Should get the correct sort when sorting by descending id', async function () {
-      const res = await getSortedBlacklistedVideosList(servers[0].url, servers[0].accessToken, '-id')
+      const res = await getBlacklistedVideosList({ url: servers[ 0 ].url, token: servers[ 0 ].accessToken, sort: '-id' })
       expect(res.body.total).to.equal(2)
 
       const blacklistedVideos = res.body.data
@@ -131,7 +162,7 @@ describe('Test video blacklist management', function () {
     })
 
     it('Should get the correct sort when sorting by descending video name', async function () {
-      const res = await getSortedBlacklistedVideosList(servers[0].url, servers[0].accessToken, '-name')
+      const res = await getBlacklistedVideosList({ url: servers[ 0 ].url, token: servers[ 0 ].accessToken, sort: '-name' })
       expect(res.body.total).to.equal(2)
 
       const blacklistedVideos = res.body.data
@@ -144,7 +175,7 @@ describe('Test video blacklist management', function () {
     })
 
     it('Should get the correct sort when sorting by ascending creation date', async function () {
-      const res = await getSortedBlacklistedVideosList(servers[0].url, servers[0].accessToken, 'createdAt')
+      const res = await getBlacklistedVideosList({ url: servers[ 0 ].url, token: servers[ 0 ].accessToken, sort: 'createdAt' })
       expect(res.body.total).to.equal(2)
 
       const blacklistedVideos = res.body.data
@@ -161,7 +192,7 @@ describe('Test video blacklist management', function () {
     it('Should change the reason', async function () {
       await updateVideoBlacklist(servers[0].url, servers[0].accessToken, videoId, 'my super reason updated')
 
-      const res = await getSortedBlacklistedVideosList(servers[0].url, servers[0].accessToken, '-name')
+      const res = await getBlacklistedVideosList({ url: servers[ 0 ].url, token: servers[ 0 ].accessToken, sort: '-name' })
       const video = res.body.data.find(b => b.video.id === videoId)
 
       expect(video.reason).to.equal('my super reason updated')
@@ -197,7 +228,7 @@ describe('Test video blacklist management', function () {
 
     it('Should remove a video from the blacklist on server 1', async function () {
       // Get one video in the blacklist
-      const res = await getSortedBlacklistedVideosList(servers[0].url, servers[0].accessToken, '-name')
+      const res = await getBlacklistedVideosList({ url: servers[ 0 ].url, token: servers[ 0 ].accessToken, sort: '-name' })
       videoToRemove = res.body.data[0]
       blacklist = res.body.data.slice(1)
 
@@ -218,7 +249,7 @@ describe('Test video blacklist management', function () {
     })
 
     it('Should not have the ex-blacklisted video in videos blacklist list on server 1', async function () {
-      const res = await getSortedBlacklistedVideosList(servers[0].url, servers[0].accessToken, '-name')
+      const res = await getBlacklistedVideosList({ url: servers[ 0 ].url, token: servers[ 0 ].accessToken, sort: '-name' })
       expect(res.body.total).to.equal(1)
 
       const videos = res.body.data
@@ -292,7 +323,7 @@ describe('Test video blacklist management', function () {
     })
 
     it('Should have the correct video blacklist unfederate attribute', async function () {
-      const res = await getSortedBlacklistedVideosList(servers[0].url, servers[0].accessToken, 'createdAt')
+      const res = await getBlacklistedVideosList({ url: servers[ 0 ].url, token: servers[ 0 ].accessToken, sort: 'createdAt' })
 
       const blacklistedVideos: VideoBlacklist[] = res.body.data
       const video3Blacklisted = blacklistedVideos.find(b => b.video.uuid === video3UUID)
@@ -317,7 +348,84 @@ describe('Test video blacklist management', function () {
 
   })
 
+  describe('When auto blacklist videos', function () {
+    let userWithoutFlag: string
+    let userWithFlag: string
+
+    before(async function () {
+      this.timeout(20000)
+
+      killallServers([ servers[0] ])
+
+      const config = {
+        'auto_blacklist': {
+          videos: {
+            'of_users': {
+              enabled: true
+            }
+          }
+        }
+      }
+      await reRunServer(servers[0], config)
+
+      {
+        const user = { username: 'user_without_flag', password: 'password' }
+        await createUser({
+          url: servers[ 0 ].url,
+          accessToken: servers[ 0 ].accessToken,
+          username: user.username,
+          adminFlags: UserAdminFlag.NONE,
+          password: user.password,
+          role: UserRole.USER
+        })
+
+        userWithoutFlag = await userLogin(servers[0], user)
+      }
+
+      {
+        const user = { username: 'user_with_flag', password: 'password' }
+        await createUser({
+          url: servers[ 0 ].url,
+          accessToken: servers[ 0 ].accessToken,
+          username: user.username,
+          adminFlags: UserAdminFlag.BY_PASS_VIDEO_AUTO_BLACKLIST,
+          password: user.password,
+          role: UserRole.USER
+        })
+
+        userWithFlag = await userLogin(servers[0], user)
+      }
+
+      await waitJobs(servers)
+    })
+
+    it('Should auto blacklist a video', async function () {
+      await uploadVideo(servers[0].url, userWithoutFlag, { name: 'blacklisted' })
+
+      const res = await getBlacklistedVideosList({
+        url: servers[ 0 ].url,
+        token: servers[ 0 ].accessToken,
+        type: VideoBlacklistType.AUTO_BEFORE_PUBLISHED
+      })
+
+      expect(res.body.total).to.equal(1)
+      expect(res.body.data[0].video.name).to.equal('blacklisted')
+    })
+
+    it('Should not auto blacklist a video', async function () {
+      await uploadVideo(servers[0].url, userWithFlag, { name: 'not blacklisted' })
+
+      const res = await getBlacklistedVideosList({
+        url: servers[ 0 ].url,
+        token: servers[ 0 ].accessToken,
+        type: VideoBlacklistType.AUTO_BEFORE_PUBLISHED
+      })
+
+      expect(res.body.total).to.equal(1)
+    })
+  })
+
   after(async function () {
-    killallServers(servers)
+    await cleanupTests(servers)
   })
 })
diff --git a/server/tests/api/videos/video-captions.ts b/server/tests/api/videos/video-captions.ts
index 57bee713f..5e13f5949 100644
--- a/server/tests/api/videos/video-captions.ts
+++ b/server/tests/api/videos/video-captions.ts
@@ -3,16 +3,21 @@
 import * as chai from 'chai'
 import 'mocha'
 import {
-  checkVideoFilesWereRemoved,
+  checkVideoFilesWereRemoved, cleanupTests,
   doubleFollow,
   flushAndRunMultipleServers,
   removeVideo,
   uploadVideo,
   wait
-} from '../../../../shared/utils'
-import { flushTests, killallServers, ServerInfo, setAccessTokensToServers } from '../../../../shared/utils/index'
-import { waitJobs } from '../../../../shared/utils/server/jobs'
-import { createVideoCaption, deleteVideoCaption, listVideoCaptions, testCaptionFile } from '../../../../shared/utils/videos/video-captions'
+} from '../../../../shared/extra-utils'
+import { flushTests, killallServers, ServerInfo, setAccessTokensToServers } from '../../../../shared/extra-utils/index'
+import { waitJobs } from '../../../../shared/extra-utils/server/jobs'
+import {
+  createVideoCaption,
+  deleteVideoCaption,
+  listVideoCaptions,
+  testCaptionFile
+} from '../../../../shared/extra-utils/videos/video-captions'
 import { VideoCaption } from '../../../../shared/models/videos/caption/video-caption.model'
 
 const expect = chai.expect
@@ -24,8 +29,6 @@ describe('Test video captions', function () {
   before(async function () {
     this.timeout(30000)
 
-    await flushTests()
-
     servers = await flushAndRunMultipleServers(2)
 
     await setAccessTokensToServers(servers)
@@ -193,6 +196,6 @@ describe('Test video captions', function () {
   })
 
   after(async function () {
-    killallServers(servers)
+    await cleanupTests(servers)
   })
 })
diff --git a/server/tests/api/videos/video-change-ownership.ts b/server/tests/api/videos/video-change-ownership.ts
index 25675a966..1c0327d40 100644
--- a/server/tests/api/videos/video-change-ownership.ts
+++ b/server/tests/api/videos/video-change-ownership.ts
@@ -4,22 +4,23 @@ import * as chai from 'chai'
 import 'mocha'
 import {
   acceptChangeOwnership,
-  changeVideoOwnership,
-  createUser, doubleFollow, flushAndRunMultipleServers,
-  flushTests,
+  changeVideoOwnership, cleanupTests,
+  createUser,
+  doubleFollow,
+  flushAndRunMultipleServers,
+  flushAndRunServer,
   getMyUserInformation,
+  getVideo,
   getVideoChangeOwnershipList,
   getVideosList,
   killallServers,
   refuseChangeOwnership,
-  runServer,
   ServerInfo,
   setAccessTokensToServers,
   uploadVideo,
-  userLogin,
-  getVideo
-} from '../../../../shared/utils'
-import { waitJobs } from '../../../../shared/utils/server/jobs'
+  userLogin
+} from '../../../../shared/extra-utils'
+import { waitJobs } from '../../../../shared/extra-utils/server/jobs'
 import { User } from '../../../../shared/models/users'
 import { VideoDetails } from '../../../../shared/models/videos'
 
@@ -46,8 +47,20 @@ describe('Test video change ownership - nominal', function () {
     await setAccessTokensToServers(servers)
 
     const videoQuota = 42000000
-    await createUser(servers[0].url, servers[0].accessToken, firstUser.username, firstUser.password, videoQuota)
-    await createUser(servers[0].url, servers[0].accessToken, secondUser.username, secondUser.password, videoQuota)
+    await createUser({
+      url: servers[ 0 ].url,
+      accessToken: servers[ 0 ].accessToken,
+      username: firstUser.username,
+      password: firstUser.password,
+      videoQuota: videoQuota
+    })
+    await createUser({
+      url: servers[ 0 ].url,
+      accessToken: servers[ 0 ].accessToken,
+      username: secondUser.username,
+      password: secondUser.password,
+      videoQuota: videoQuota
+    })
 
     firstUserAccessToken = await userLogin(servers[0], firstUser)
     secondUserAccessToken = await userLogin(servers[0], secondUser)
@@ -190,7 +203,7 @@ describe('Test video change ownership - nominal', function () {
     }
   })
 
-  after(async function () {
+  after(function () {
     killallServers(servers)
   })
 })
@@ -213,14 +226,25 @@ describe('Test video change ownership - quota too small', function () {
     this.timeout(50000)
 
     // Run one server
-    await flushTests()
-    server = await runServer(1)
+    server = await flushAndRunServer(1)
     await setAccessTokensToServers([server])
 
     const videoQuota = 42000000
     const limitedVideoQuota = 10
-    await createUser(server.url, server.accessToken, firstUser.username, firstUser.password, videoQuota)
-    await createUser(server.url, server.accessToken, secondUser.username, secondUser.password, limitedVideoQuota)
+    await createUser({
+      url: server.url,
+      accessToken: server.accessToken,
+      username: firstUser.username,
+      password: firstUser.password,
+      videoQuota: videoQuota
+    })
+    await createUser({
+      url: server.url,
+      accessToken: server.accessToken,
+      username: secondUser.username,
+      password: secondUser.password,
+      videoQuota: limitedVideoQuota
+    })
 
     firstUserAccessToken = await userLogin(server, firstUser)
     secondUserAccessToken = await userLogin(server, secondUser)
@@ -274,6 +298,6 @@ describe('Test video change ownership - quota too small', function () {
   })
 
   after(async function () {
-    killallServers([server])
+    await cleanupTests([ server ])
   })
 })
diff --git a/server/tests/api/videos/video-channels.ts b/server/tests/api/videos/video-channels.ts
index 63514d69c..345e96f43 100644
--- a/server/tests/api/videos/video-channels.ts
+++ b/server/tests/api/videos/video-channels.ts
@@ -4,6 +4,7 @@ import * as chai from 'chai'
 import 'mocha'
 import { User, Video } from '../../../../shared/index'
 import {
+  cleanupTests,
   createUser,
   doubleFollow,
   flushAndRunMultipleServers,
@@ -13,7 +14,7 @@ import {
   updateVideoChannelAvatar,
   uploadVideo,
   userLogin
-} from '../../../../shared/utils'
+} from '../../../../shared/extra-utils'
 import {
   addVideoChannel,
   deleteVideoChannel,
@@ -26,8 +27,8 @@ import {
   ServerInfo,
   setAccessTokensToServers,
   updateVideoChannel
-} from '../../../../shared/utils/index'
-import { waitJobs } from '../../../../shared/utils/server/jobs'
+} from '../../../../shared/extra-utils/index'
+import { waitJobs } from '../../../../shared/extra-utils/server/jobs'
 
 const expect = chai.expect
 
@@ -42,8 +43,6 @@ describe('Test video channels', function () {
   before(async function () {
     this.timeout(30000)
 
-    await flushTests()
-
     servers = await flushAndRunMultipleServers(2)
 
     await setAccessTokensToServers(servers)
@@ -270,7 +269,7 @@ describe('Test video channels', function () {
     }
 
     {
-      await createUser(servers[ 0 ].url, servers[ 0 ].accessToken, 'toto', 'password')
+      await createUser({ url: servers[ 0 ].url, accessToken: servers[ 0 ].accessToken, username: 'toto', password: 'password' })
       const accessToken = await userLogin(servers[ 0 ], { username: 'toto', password: 'password' })
 
       const res = await getMyUserInformation(servers[ 0 ].url, accessToken)
@@ -280,6 +279,6 @@ describe('Test video channels', function () {
   })
 
   after(async function () {
-    killallServers(servers)
+    await cleanupTests(servers)
   })
 })
diff --git a/server/tests/api/videos/video-comments.ts b/server/tests/api/videos/video-comments.ts
index ce1b17e35..22fd8c058 100644
--- a/server/tests/api/videos/video-comments.ts
+++ b/server/tests/api/videos/video-comments.ts
@@ -3,24 +3,22 @@
 import * as chai from 'chai'
 import 'mocha'
 import { VideoComment, VideoCommentThreadTree } from '../../../../shared/models/videos/video-comment.model'
-import { testImage } from '../../../../shared/utils'
+import { cleanupTests, testImage } from '../../../../shared/extra-utils'
 import {
   dateIsValid,
-  flushTests,
-  killallServers,
-  runServer,
+  flushAndRunServer,
   ServerInfo,
   setAccessTokensToServers,
   updateMyAvatar,
   uploadVideo
-} from '../../../../shared/utils/index'
+} from '../../../../shared/extra-utils/index'
 import {
   addVideoCommentReply,
   addVideoCommentThread,
   deleteVideoComment,
   getVideoCommentThreads,
   getVideoThreadComments
-} from '../../../../shared/utils/videos/video-comments'
+} from '../../../../shared/extra-utils/videos/video-comments'
 
 const expect = chai.expect
 
@@ -34,9 +32,7 @@ describe('Test video comments', function () {
   before(async function () {
     this.timeout(30000)
 
-    await flushTests()
-
-    server = await runServer(1)
+    server = await flushAndRunServer(1)
 
     await setAccessTokensToServers([ server ])
 
@@ -202,6 +198,6 @@ describe('Test video comments', function () {
   })
 
   after(async function () {
-    killallServers([ server ])
+    await cleanupTests([ server ])
   })
 })
diff --git a/server/tests/api/videos/video-description.ts b/server/tests/api/videos/video-description.ts
index cbda0b9a6..db4d278bf 100644
--- a/server/tests/api/videos/video-description.ts
+++ b/server/tests/api/videos/video-description.ts
@@ -3,6 +3,7 @@
 import * as chai from 'chai'
 import 'mocha'
 import {
+  cleanupTests,
   flushAndRunMultipleServers,
   getVideo,
   getVideoDescription,
@@ -12,9 +13,9 @@ import {
   setAccessTokensToServers,
   updateVideo,
   uploadVideo
-} from '../../../../shared/utils/index'
-import { doubleFollow } from '../../../../shared/utils/server/follows'
-import { waitJobs } from '../../../../shared/utils/server/jobs'
+} from '../../../../shared/extra-utils/index'
+import { doubleFollow } from '../../../../shared/extra-utils/server/follows'
+import { waitJobs } from '../../../../shared/extra-utils/server/jobs'
 
 const expect = chai.expect
 
@@ -100,6 +101,6 @@ describe('Test video description', function () {
   })
 
   after(async function () {
-    killallServers(servers)
+    await cleanupTests(servers)
   })
 })
diff --git a/server/tests/api/videos/video-hls.ts b/server/tests/api/videos/video-hls.ts
new file mode 100644
index 000000000..22031c18b
--- /dev/null
+++ b/server/tests/api/videos/video-hls.ts
@@ -0,0 +1,134 @@
+/* tslint:disable:no-unused-expression */
+
+import * as chai from 'chai'
+import 'mocha'
+import {
+  checkDirectoryIsEmpty,
+  checkSegmentHash,
+  checkTmpIsEmpty, cleanupTests,
+  doubleFollow,
+  flushAndRunMultipleServers,
+  flushTests,
+  getPlaylist,
+  getVideo,
+  killallServers,
+  removeVideo,
+  ServerInfo,
+  setAccessTokensToServers,
+  updateVideo,
+  uploadVideo,
+  waitJobs
+} from '../../../../shared/extra-utils'
+import { VideoDetails } from '../../../../shared/models/videos'
+import { VideoStreamingPlaylistType } from '../../../../shared/models/videos/video-streaming-playlist.type'
+import { join } from 'path'
+
+const expect = chai.expect
+
+async function checkHlsPlaylist (servers: ServerInfo[], videoUUID: string) {
+  const resolutions = [ 240, 360, 480, 720 ]
+
+  for (const server of servers) {
+    const res = await getVideo(server.url, videoUUID)
+    const videoDetails: VideoDetails = res.body
+
+    expect(videoDetails.streamingPlaylists).to.have.lengthOf(1)
+
+    const hlsPlaylist = videoDetails.streamingPlaylists.find(p => p.type === VideoStreamingPlaylistType.HLS)
+    expect(hlsPlaylist).to.not.be.undefined
+
+    {
+      const res2 = await getPlaylist(hlsPlaylist.playlistUrl)
+
+      const masterPlaylist = res2.text
+
+      expect(masterPlaylist).to.contain('#EXT-X-STREAM-INF:BANDWIDTH=55472,RESOLUTION=640x360,FRAME-RATE=25')
+
+      for (const resolution of resolutions) {
+        expect(masterPlaylist).to.contain(`${resolution}.m3u8`)
+      }
+    }
+
+    {
+      for (const resolution of resolutions) {
+        const res2 = await getPlaylist(`http://localhost:9001/static/streaming-playlists/hls/${videoUUID}/${resolution}.m3u8`)
+
+        const subPlaylist = res2.text
+        expect(subPlaylist).to.contain(`${videoUUID}-${resolution}-fragmented.mp4`)
+      }
+    }
+
+    {
+      const baseUrl = 'http://localhost:9001/static/streaming-playlists/hls'
+
+      for (const resolution of resolutions) {
+        await checkSegmentHash(baseUrl, baseUrl, videoUUID, resolution, hlsPlaylist)
+      }
+    }
+  }
+}
+
+describe('Test HLS videos', function () {
+  let servers: ServerInfo[] = []
+  let videoUUID = ''
+
+  before(async function () {
+    this.timeout(120000)
+
+    servers = await flushAndRunMultipleServers(2, { transcoding: { enabled: true, hls: { enabled: true } } })
+
+    // Get the access tokens
+    await setAccessTokensToServers(servers)
+
+    // Server 1 and server 2 follow each other
+    await doubleFollow(servers[0], servers[1])
+  })
+
+  it('Should upload a video and transcode it to HLS', async function () {
+    this.timeout(120000)
+
+    {
+      const res = await uploadVideo(servers[ 0 ].url, servers[ 0 ].accessToken, { name: 'video 1', fixture: 'video_short.webm' })
+      videoUUID = res.body.video.uuid
+    }
+
+    await waitJobs(servers)
+
+    await checkHlsPlaylist(servers, videoUUID)
+  })
+
+  it('Should update the video', async function () {
+    await updateVideo(servers[0].url, servers[0].accessToken, videoUUID, { name: 'video 1 updated' })
+
+    await waitJobs(servers)
+
+    await checkHlsPlaylist(servers, videoUUID)
+  })
+
+  it('Should delete the video', async function () {
+    await removeVideo(servers[0].url, servers[0].accessToken, videoUUID)
+
+    await waitJobs(servers)
+
+    for (const server of servers) {
+      await getVideo(server.url, videoUUID, 404)
+    }
+  })
+
+  it('Should have the playlists/segment deleted from the disk', async function () {
+    for (const server of servers) {
+      await checkDirectoryIsEmpty(server, 'videos')
+      await checkDirectoryIsEmpty(server, join('streaming-playlists', 'hls'))
+    }
+  })
+
+  it('Should have an empty tmp directory', async function () {
+    for (const server of servers) {
+      await checkTmpIsEmpty(server)
+    }
+  })
+
+  after(async function () {
+    await cleanupTests(servers)
+  })
+})
diff --git a/server/tests/api/videos/video-imports.ts b/server/tests/api/videos/video-imports.ts
index cd4988553..1233ed6eb 100644
--- a/server/tests/api/videos/video-imports.ts
+++ b/server/tests/api/videos/video-imports.ts
@@ -4,6 +4,7 @@ import * as chai from 'chai'
 import 'mocha'
 import { VideoDetails, VideoImport, VideoPrivacy } from '../../../../shared/models/videos'
 import {
+  cleanupTests,
   doubleFollow,
   flushAndRunMultipleServers,
   getMyUserInformation,
@@ -14,9 +15,9 @@ import {
   killallServers,
   ServerInfo,
   setAccessTokensToServers
-} from '../../../../shared/utils'
-import { waitJobs } from '../../../../shared/utils/server/jobs'
-import { getMagnetURI, getYoutubeVideoUrl, importVideo, getMyVideoImports } from '../../../../shared/utils/videos/video-imports'
+} from '../../../../shared/extra-utils'
+import { waitJobs } from '../../../../shared/extra-utils/server/jobs'
+import { getMagnetURI, getYoutubeVideoUrl, importVideo, getMyVideoImports } from '../../../../shared/extra-utils/videos/video-imports'
 
 const expect = chai.expect
 
@@ -38,6 +39,11 @@ describe('Test video imports', function () {
     expect(videoHttp.tags).to.deep.equal([ 'tag1', 'tag2' ])
     expect(videoHttp.files).to.have.lengthOf(1)
 
+    const originallyPublishedAt = new Date(videoHttp.originallyPublishedAt)
+    expect(originallyPublishedAt.getDate()).to.equal(14)
+    expect(originallyPublishedAt.getMonth()).to.equal(0)
+    expect(originallyPublishedAt.getFullYear()).to.equal(2019)
+
     const resMagnet = await getVideo(url, idMagnet)
     const videoMagnet: VideoDetails = resMagnet.body
     const resTorrent = await getVideo(url, idTorrent)
@@ -237,6 +243,6 @@ describe('Test video imports', function () {
   })
 
   after(async function () {
-    killallServers(servers)
+    await cleanupTests(servers)
   })
 })
diff --git a/server/tests/api/videos/video-nsfw.ts b/server/tests/api/videos/video-nsfw.ts
index df1ee2eb9..ad6a4b43f 100644
--- a/server/tests/api/videos/video-nsfw.ts
+++ b/server/tests/api/videos/video-nsfw.ts
@@ -2,30 +2,23 @@
 
 import * as chai from 'chai'
 import 'mocha'
+import { cleanupTests, getVideosList, ServerInfo, setAccessTokensToServers, uploadVideo } from '../../../../shared/extra-utils/index'
+import { userLogin } from '../../../../shared/extra-utils/users/login'
+import { createUser } from '../../../../shared/extra-utils/users/users'
+import { getMyVideos } from '../../../../shared/extra-utils/videos/videos'
 import {
-  flushTests,
-  getVideosList,
-  killallServers,
-  ServerInfo,
-  setAccessTokensToServers,
-  uploadVideo
-} from '../../../../shared/utils/index'
-import { userLogin } from '../../../../shared/utils/users/login'
-import { createUser } from '../../../../shared/utils/users/users'
-import { getMyVideos } from '../../../../shared/utils/videos/videos'
-import {
+  flushAndRunServer,
   getAccountVideos,
   getConfig,
   getCustomConfig,
   getMyUserInformation,
   getVideoChannelVideos,
   getVideosListWithToken,
-  runServer,
   searchVideo,
   searchVideoWithToken,
   updateCustomConfig,
   updateMyUser
-} from '../../../../shared/utils'
+} from '../../../../shared/extra-utils'
 import { ServerConfig } from '../../../../shared/models'
 import { CustomConfig } from '../../../../shared/models/server/custom-config.model'
 import { User } from '../../../../shared/models/users'
@@ -64,9 +57,7 @@ describe('Test video NSFW policy', function () {
 
   before(async function () {
     this.timeout(50000)
-
-    await flushTests()
-    server = await runServer(1)
+    server = await flushAndRunServer(1)
 
     // Get the access tokens
     await setAccessTokensToServers([ server ])
@@ -144,7 +135,7 @@ describe('Test video NSFW policy', function () {
     it('Should create a user having the default nsfw policy', async function () {
       const username = 'user1'
       const password = 'my super password'
-      await createUser(server.url, server.accessToken, username, password)
+      await createUser({ url: server.url, accessToken: server.accessToken, username: username, password: password })
 
       userAccessToken = await userLogin(server, { username, password })
 
@@ -244,6 +235,6 @@ describe('Test video NSFW policy', function () {
   })
 
   after(async function () {
-    killallServers([ server ])
+    await cleanupTests([ server ])
   })
 })
diff --git a/server/tests/api/videos/video-playlists.ts b/server/tests/api/videos/video-playlists.ts
new file mode 100644
index 000000000..e4d817ff8
--- /dev/null
+++ b/server/tests/api/videos/video-playlists.ts
@@ -0,0 +1,867 @@
+/* tslint:disable:no-unused-expression */
+
+import * as chai from 'chai'
+import 'mocha'
+import {
+  addVideoChannel,
+  addVideoInPlaylist,
+  checkPlaylistFilesWereRemoved,
+  cleanupTests,
+  createUser,
+  createVideoPlaylist,
+  deleteVideoChannel,
+  deleteVideoPlaylist,
+  doubleFollow,
+  doVideosExistInMyPlaylist,
+  flushAndRunMultipleServers,
+  getAccountPlaylistsList,
+  getAccountPlaylistsListWithToken,
+  getMyUserInformation,
+  getPlaylistVideos,
+  getVideoChannelPlaylistsList,
+  getVideoPlaylist,
+  getVideoPlaylistPrivacies,
+  getVideoPlaylistsList,
+  getVideoPlaylistWithToken,
+  removeUser,
+  removeVideoFromPlaylist,
+  reorderVideosPlaylist,
+  ServerInfo,
+  setAccessTokensToServers,
+  setDefaultVideoChannel,
+  testImage,
+  unfollow,
+  updateVideoPlaylist,
+  updateVideoPlaylistElement,
+  uploadVideo,
+  uploadVideoAndGetId,
+  userLogin,
+  waitJobs
+} from '../../../../shared/extra-utils'
+import { VideoPlaylistPrivacy } from '../../../../shared/models/videos/playlist/video-playlist-privacy.model'
+import { VideoPlaylist } from '../../../../shared/models/videos/playlist/video-playlist.model'
+import { Video } from '../../../../shared/models/videos'
+import { VideoPlaylistType } from '../../../../shared/models/videos/playlist/video-playlist-type.model'
+import { VideoExistInPlaylist } from '../../../../shared/models/videos/playlist/video-exist-in-playlist.model'
+import { User } from '../../../../shared/models/users'
+
+const expect = chai.expect
+
+describe('Test video playlists', function () {
+  let servers: ServerInfo[] = []
+
+  let playlistServer2Id1: number
+  let playlistServer2Id2: number
+  let playlistServer2UUID2: number
+
+  let playlistServer1Id: number
+  let playlistServer1UUID: string
+
+  let nsfwVideoServer1: number
+
+  before(async function () {
+    this.timeout(120000)
+
+    servers = await flushAndRunMultipleServers(3, { transcoding: { enabled: false } })
+
+    // Get the access tokens
+    await setAccessTokensToServers(servers)
+    await setDefaultVideoChannel(servers)
+
+    // Server 1 and server 2 follow each other
+    await doubleFollow(servers[0], servers[1])
+    // Server 1 and server 3 follow each other
+    await doubleFollow(servers[0], servers[2])
+
+    {
+      const serverPromises: Promise<any>[][] = []
+
+      for (const server of servers) {
+        const videoPromises: Promise<any>[] = []
+
+        for (let i = 0; i < 7; i++) {
+          videoPromises.push(
+            uploadVideo(server.url, server.accessToken, { name: `video ${i} server ${server.serverNumber}`, nsfw: false })
+              .then(res => res.body.video)
+          )
+        }
+
+        serverPromises.push(videoPromises)
+      }
+
+      servers[0].videos = await Promise.all(serverPromises[0])
+      servers[1].videos = await Promise.all(serverPromises[1])
+      servers[2].videos = await Promise.all(serverPromises[2])
+    }
+
+    nsfwVideoServer1 = (await uploadVideoAndGetId({ server: servers[ 0 ], videoName: 'NSFW video', nsfw: true })).id
+
+    await waitJobs(servers)
+  })
+
+  it('Should list video playlist privacies', async function () {
+    const res = await getVideoPlaylistPrivacies(servers[0].url)
+
+    const privacies = res.body
+    expect(Object.keys(privacies)).to.have.length.at.least(3)
+
+    expect(privacies[3]).to.equal('Private')
+  })
+
+  it('Should list watch later playlist', async function () {
+    const url = servers[ 0 ].url
+    const accessToken = servers[ 0 ].accessToken
+
+    {
+      const res = await getAccountPlaylistsListWithToken(url, accessToken, 'root', 0, 5, VideoPlaylistType.WATCH_LATER)
+
+      expect(res.body.total).to.equal(1)
+      expect(res.body.data).to.have.lengthOf(1)
+
+      const playlist: VideoPlaylist = res.body.data[ 0 ]
+      expect(playlist.displayName).to.equal('Watch later')
+      expect(playlist.type.id).to.equal(VideoPlaylistType.WATCH_LATER)
+      expect(playlist.type.label).to.equal('Watch later')
+    }
+
+    {
+      const res = await getAccountPlaylistsListWithToken(url, accessToken, 'root', 0, 5, VideoPlaylistType.REGULAR)
+
+      expect(res.body.total).to.equal(0)
+      expect(res.body.data).to.have.lengthOf(0)
+    }
+
+    {
+      const res = await getAccountPlaylistsList(url, 'root', 0, 5)
+      expect(res.body.total).to.equal(0)
+      expect(res.body.data).to.have.lengthOf(0)
+    }
+  })
+
+  it('Should create a playlist on server 1 and have the playlist on server 2 and 3', async function () {
+    this.timeout(30000)
+
+    await createVideoPlaylist({
+      url: servers[0].url,
+      token: servers[0].accessToken,
+      playlistAttrs: {
+        displayName: 'my super playlist',
+        privacy: VideoPlaylistPrivacy.PUBLIC,
+        description: 'my super description',
+        thumbnailfile: 'thumbnail.jpg',
+        videoChannelId: servers[0].videoChannel.id
+      }
+    })
+
+    await waitJobs(servers)
+
+    for (const server of servers) {
+      const res = await getVideoPlaylistsList(server.url, 0, 5)
+      expect(res.body.total).to.equal(1)
+      expect(res.body.data).to.have.lengthOf(1)
+
+      const playlistFromList = res.body.data[0] as VideoPlaylist
+
+      const res2 = await getVideoPlaylist(server.url, playlistFromList.uuid)
+      const playlistFromGet = res2.body
+
+      for (const playlist of [ playlistFromGet, playlistFromList ]) {
+        expect(playlist.id).to.be.a('number')
+        expect(playlist.uuid).to.be.a('string')
+
+        expect(playlist.isLocal).to.equal(server.serverNumber === 1)
+
+        expect(playlist.displayName).to.equal('my super playlist')
+        expect(playlist.description).to.equal('my super description')
+        expect(playlist.privacy.id).to.equal(VideoPlaylistPrivacy.PUBLIC)
+        expect(playlist.privacy.label).to.equal('Public')
+        expect(playlist.type.id).to.equal(VideoPlaylistType.REGULAR)
+        expect(playlist.type.label).to.equal('Regular')
+
+        expect(playlist.videosLength).to.equal(0)
+
+        expect(playlist.ownerAccount.name).to.equal('root')
+        expect(playlist.ownerAccount.displayName).to.equal('root')
+        expect(playlist.videoChannel.name).to.equal('root_channel')
+        expect(playlist.videoChannel.displayName).to.equal('Main root channel')
+      }
+    }
+  })
+
+  it('Should create a playlist on server 2 and have the playlist on server 1 but not on server 3', async function () {
+    this.timeout(30000)
+
+    {
+      const res = await createVideoPlaylist({
+        url: servers[1].url,
+        token: servers[1].accessToken,
+        playlistAttrs: {
+          displayName: 'playlist 2',
+          privacy: VideoPlaylistPrivacy.PUBLIC,
+          videoChannelId: servers[1].videoChannel.id
+        }
+      })
+      playlistServer2Id1 = res.body.videoPlaylist.id
+    }
+
+    {
+      const res = await createVideoPlaylist({
+        url: servers[ 1 ].url,
+        token: servers[ 1 ].accessToken,
+        playlistAttrs: {
+          displayName: 'playlist 3',
+          privacy: VideoPlaylistPrivacy.PUBLIC,
+          thumbnailfile: 'thumbnail.jpg',
+          videoChannelId: servers[1].videoChannel.id
+        }
+      })
+
+      playlistServer2Id2 = res.body.videoPlaylist.id
+      playlistServer2UUID2 = res.body.videoPlaylist.uuid
+    }
+
+    for (let id of [ playlistServer2Id1, playlistServer2Id2 ]) {
+      await addVideoInPlaylist({
+        url: servers[ 1 ].url,
+        token: servers[ 1 ].accessToken,
+        playlistId: id,
+        elementAttrs: { videoId: servers[ 1 ].videos[ 0 ].id, startTimestamp: 1, stopTimestamp: 2 }
+      })
+      await addVideoInPlaylist({
+        url: servers[ 1 ].url,
+        token: servers[ 1 ].accessToken,
+        playlistId: id,
+        elementAttrs: { videoId: servers[ 1 ].videos[ 1 ].id }
+      })
+    }
+
+    await waitJobs(servers)
+
+    for (const server of [ servers[0], servers[1] ]) {
+      const res = await getVideoPlaylistsList(server.url, 0, 5)
+
+      const playlist2 = res.body.data.find(p => p.displayName === 'playlist 2')
+      expect(playlist2).to.not.be.undefined
+      await testImage(server.url, 'thumbnail-playlist', playlist2.thumbnailPath)
+
+      const playlist3 = res.body.data.find(p => p.displayName === 'playlist 3')
+      expect(playlist3).to.not.be.undefined
+      await testImage(server.url, 'thumbnail', playlist3.thumbnailPath)
+    }
+
+    const res = await getVideoPlaylistsList(servers[2].url, 0, 5)
+    expect(res.body.data.find(p => p.displayName === 'playlist 2')).to.be.undefined
+    expect(res.body.data.find(p => p.displayName === 'playlist 3')).to.be.undefined
+  })
+
+  it('Should have the playlist on server 3 after a new follow', async function () {
+    this.timeout(30000)
+
+    // Server 2 and server 3 follow each other
+    await doubleFollow(servers[1], servers[2])
+
+    const res = await getVideoPlaylistsList(servers[2].url, 0, 5)
+
+    const playlist2 = res.body.data.find(p => p.displayName === 'playlist 2')
+    expect(playlist2).to.not.be.undefined
+    await testImage(servers[2].url, 'thumbnail-playlist', playlist2.thumbnailPath)
+
+    expect(res.body.data.find(p => p.displayName === 'playlist 3')).to.not.be.undefined
+  })
+
+  it('Should correctly list the playlists', async function () {
+    this.timeout(30000)
+
+    {
+      const res = await getVideoPlaylistsList(servers[ 2 ].url, 1, 2, 'createdAt')
+
+      expect(res.body.total).to.equal(3)
+
+      const data: VideoPlaylist[] = res.body.data
+      expect(data).to.have.lengthOf(2)
+      expect(data[ 0 ].displayName).to.equal('playlist 2')
+      expect(data[ 1 ].displayName).to.equal('playlist 3')
+    }
+
+    {
+      const res = await getVideoPlaylistsList(servers[ 2 ].url, 1, 2, '-createdAt')
+
+      expect(res.body.total).to.equal(3)
+
+      const data: VideoPlaylist[] = res.body.data
+      expect(data).to.have.lengthOf(2)
+      expect(data[ 0 ].displayName).to.equal('playlist 2')
+      expect(data[ 1 ].displayName).to.equal('my super playlist')
+    }
+  })
+
+  it('Should list video channel playlists', async function () {
+    this.timeout(30000)
+
+    {
+      const res = await getVideoChannelPlaylistsList(servers[ 0 ].url, 'root_channel', 0, 2, '-createdAt')
+
+      expect(res.body.total).to.equal(1)
+
+      const data: VideoPlaylist[] = res.body.data
+      expect(data).to.have.lengthOf(1)
+      expect(data[ 0 ].displayName).to.equal('my super playlist')
+    }
+  })
+
+  it('Should list account playlists', async function () {
+    this.timeout(30000)
+
+    {
+      const res = await getAccountPlaylistsList(servers[ 1 ].url, 'root', 1, 2, '-createdAt')
+
+      expect(res.body.total).to.equal(2)
+
+      const data: VideoPlaylist[] = res.body.data
+      expect(data).to.have.lengthOf(1)
+      expect(data[ 0 ].displayName).to.equal('playlist 2')
+    }
+
+    {
+      const res = await getAccountPlaylistsList(servers[ 1 ].url, 'root', 1, 2, 'createdAt')
+
+      expect(res.body.total).to.equal(2)
+
+      const data: VideoPlaylist[] = res.body.data
+      expect(data).to.have.lengthOf(1)
+      expect(data[ 0 ].displayName).to.equal('playlist 3')
+    }
+  })
+
+  it('Should not list unlisted or private playlists', async function () {
+    this.timeout(30000)
+
+    await createVideoPlaylist({
+      url: servers[ 1 ].url,
+      token: servers[ 1 ].accessToken,
+      playlistAttrs: {
+        displayName: 'playlist unlisted',
+        privacy: VideoPlaylistPrivacy.UNLISTED
+      }
+    })
+
+    await createVideoPlaylist({
+      url: servers[ 1 ].url,
+      token: servers[ 1 ].accessToken,
+      playlistAttrs: {
+        displayName: 'playlist private',
+        privacy: VideoPlaylistPrivacy.PRIVATE
+      }
+    })
+
+    await waitJobs(servers)
+
+    for (const server of servers) {
+      const results = [
+        await getAccountPlaylistsList(server.url, 'root@localhost:9002', 0, 5, '-createdAt'),
+        await getVideoPlaylistsList(server.url, 0, 2, '-createdAt')
+      ]
+
+      expect(results[0].body.total).to.equal(2)
+      expect(results[1].body.total).to.equal(3)
+
+      for (const res of results) {
+        const data: VideoPlaylist[] = res.body.data
+        expect(data).to.have.lengthOf(2)
+        expect(data[ 0 ].displayName).to.equal('playlist 3')
+        expect(data[ 1 ].displayName).to.equal('playlist 2')
+      }
+    }
+  })
+
+  it('Should update a playlist', async function () {
+    this.timeout(30000)
+
+    await updateVideoPlaylist({
+      url: servers[1].url,
+      token: servers[1].accessToken,
+      playlistAttrs: {
+        displayName: 'playlist 3 updated',
+        description: 'description updated',
+        privacy: VideoPlaylistPrivacy.UNLISTED,
+        thumbnailfile: 'thumbnail.jpg',
+        videoChannelId: servers[1].videoChannel.id
+      },
+      playlistId: playlistServer2Id2
+    })
+
+    await waitJobs(servers)
+
+    for (const server of servers) {
+      const res = await getVideoPlaylist(server.url, playlistServer2UUID2)
+      const playlist: VideoPlaylist = res.body
+
+      expect(playlist.displayName).to.equal('playlist 3 updated')
+      expect(playlist.description).to.equal('description updated')
+
+      expect(playlist.privacy.id).to.equal(VideoPlaylistPrivacy.UNLISTED)
+      expect(playlist.privacy.label).to.equal('Unlisted')
+
+      expect(playlist.type.id).to.equal(VideoPlaylistType.REGULAR)
+      expect(playlist.type.label).to.equal('Regular')
+
+      expect(playlist.videosLength).to.equal(2)
+
+      expect(playlist.ownerAccount.name).to.equal('root')
+      expect(playlist.ownerAccount.displayName).to.equal('root')
+      expect(playlist.videoChannel.name).to.equal('root_channel')
+      expect(playlist.videoChannel.displayName).to.equal('Main root channel')
+    }
+  })
+
+  it('Should create a playlist containing different startTimestamp/endTimestamp videos', async function () {
+    this.timeout(30000)
+
+    const addVideo = (elementAttrs: any) => {
+      return addVideoInPlaylist({ url: servers[0].url, token: servers[0].accessToken, playlistId: playlistServer1Id, elementAttrs })
+    }
+
+    const res = await createVideoPlaylist({
+      url: servers[ 0 ].url,
+      token: servers[ 0 ].accessToken,
+      playlistAttrs: {
+        displayName: 'playlist 4',
+        privacy: VideoPlaylistPrivacy.PUBLIC,
+        videoChannelId: servers[0].videoChannel.id
+      }
+    })
+
+    playlistServer1Id = res.body.videoPlaylist.id
+    playlistServer1UUID = res.body.videoPlaylist.uuid
+
+    await addVideo({ videoId: servers[0].videos[0].uuid, startTimestamp: 15, stopTimestamp: 28 })
+    await addVideo({ videoId: servers[2].videos[1].uuid, startTimestamp: 35 })
+    await addVideo({ videoId: servers[2].videos[2].uuid })
+    await addVideo({ videoId: servers[0].videos[3].uuid, stopTimestamp: 35 })
+    await addVideo({ videoId: servers[0].videos[4].uuid, startTimestamp: 45, stopTimestamp: 60 })
+    await addVideo({ videoId: nsfwVideoServer1, startTimestamp: 5 })
+
+    await waitJobs(servers)
+  })
+
+  it('Should correctly list playlist videos', async function () {
+    this.timeout(30000)
+
+    for (const server of servers) {
+      const res = await getPlaylistVideos(server.url, server.accessToken, playlistServer1UUID, 0, 10)
+
+      expect(res.body.total).to.equal(6)
+
+      const videos: Video[] = res.body.data
+      expect(videos).to.have.lengthOf(6)
+
+      expect(videos[0].name).to.equal('video 0 server 1')
+      expect(videos[0].playlistElement.position).to.equal(1)
+      expect(videos[0].playlistElement.startTimestamp).to.equal(15)
+      expect(videos[0].playlistElement.stopTimestamp).to.equal(28)
+
+      expect(videos[1].name).to.equal('video 1 server 3')
+      expect(videos[1].playlistElement.position).to.equal(2)
+      expect(videos[1].playlistElement.startTimestamp).to.equal(35)
+      expect(videos[1].playlistElement.stopTimestamp).to.be.null
+
+      expect(videos[2].name).to.equal('video 2 server 3')
+      expect(videos[2].playlistElement.position).to.equal(3)
+      expect(videos[2].playlistElement.startTimestamp).to.be.null
+      expect(videos[2].playlistElement.stopTimestamp).to.be.null
+
+      expect(videos[3].name).to.equal('video 3 server 1')
+      expect(videos[3].playlistElement.position).to.equal(4)
+      expect(videos[3].playlistElement.startTimestamp).to.be.null
+      expect(videos[3].playlistElement.stopTimestamp).to.equal(35)
+
+      expect(videos[4].name).to.equal('video 4 server 1')
+      expect(videos[4].playlistElement.position).to.equal(5)
+      expect(videos[4].playlistElement.startTimestamp).to.equal(45)
+      expect(videos[4].playlistElement.stopTimestamp).to.equal(60)
+
+      expect(videos[5].name).to.equal('NSFW video')
+      expect(videos[5].playlistElement.position).to.equal(6)
+      expect(videos[5].playlistElement.startTimestamp).to.equal(5)
+      expect(videos[5].playlistElement.stopTimestamp).to.be.null
+
+      const res2 = await getPlaylistVideos(server.url, server.accessToken, playlistServer1UUID, 0, 10, { nsfw: false })
+      expect(res2.body.total).to.equal(5)
+      expect(res2.body.data.find(v => v.name === 'NSFW video')).to.be.undefined
+
+      const res3 = await getPlaylistVideos(server.url, server.accessToken, playlistServer1UUID, 0, 2)
+      expect(res3.body.data).to.have.lengthOf(2)
+    }
+  })
+
+  it('Should reorder the playlist', async function () {
+    this.timeout(30000)
+
+    {
+      await reorderVideosPlaylist({
+        url: servers[ 0 ].url,
+        token: servers[ 0 ].accessToken,
+        playlistId: playlistServer1Id,
+        elementAttrs: {
+          startPosition: 2,
+          insertAfterPosition: 3
+        }
+      })
+
+      await waitJobs(servers)
+
+      for (const server of servers) {
+        const res = await getPlaylistVideos(server.url, server.accessToken, playlistServer1UUID, 0, 10)
+        const names = res.body.data.map(v => v.name)
+
+        expect(names).to.deep.equal([
+          'video 0 server 1',
+          'video 2 server 3',
+          'video 1 server 3',
+          'video 3 server 1',
+          'video 4 server 1',
+          'NSFW video'
+        ])
+      }
+    }
+
+    {
+      await reorderVideosPlaylist({
+        url: servers[0].url,
+        token: servers[0].accessToken,
+        playlistId: playlistServer1Id,
+        elementAttrs: {
+          startPosition: 1,
+          reorderLength: 3,
+          insertAfterPosition: 4
+        }
+      })
+
+      await waitJobs(servers)
+
+      for (const server of servers) {
+        const res = await getPlaylistVideos(server.url, server.accessToken, playlistServer1UUID, 0, 10)
+        const names = res.body.data.map(v => v.name)
+
+        expect(names).to.deep.equal([
+          'video 3 server 1',
+          'video 0 server 1',
+          'video 2 server 3',
+          'video 1 server 3',
+          'video 4 server 1',
+          'NSFW video'
+        ])
+      }
+    }
+
+    {
+      await reorderVideosPlaylist({
+        url: servers[0].url,
+        token: servers[0].accessToken,
+        playlistId: playlistServer1Id,
+        elementAttrs: {
+          startPosition: 6,
+          insertAfterPosition: 3
+        }
+      })
+
+      await waitJobs(servers)
+
+      for (const server of servers) {
+        const res = await getPlaylistVideos(server.url, server.accessToken, playlistServer1UUID, 0, 10)
+        const videos: Video[] = res.body.data
+
+        const names = videos.map(v => v.name)
+
+        expect(names).to.deep.equal([
+          'video 3 server 1',
+          'video 0 server 1',
+          'video 2 server 3',
+          'NSFW video',
+          'video 1 server 3',
+          'video 4 server 1'
+        ])
+
+        for (let i = 1; i <= videos.length; i++) {
+          expect(videos[i - 1].playlistElement.position).to.equal(i)
+        }
+      }
+    }
+  })
+
+  it('Should update startTimestamp/endTimestamp of some elements', async function () {
+    this.timeout(30000)
+
+    await updateVideoPlaylistElement({
+      url: servers[0].url,
+      token: servers[0].accessToken,
+      playlistId: playlistServer1Id,
+      videoId: servers[0].videos[3].uuid,
+      elementAttrs: {
+        startTimestamp: 1
+      }
+    })
+
+    await updateVideoPlaylistElement({
+      url: servers[0].url,
+      token: servers[0].accessToken,
+      playlistId: playlistServer1Id,
+      videoId: servers[0].videos[4].uuid,
+      elementAttrs: {
+        stopTimestamp: null
+      }
+    })
+
+    await waitJobs(servers)
+
+    for (const server of servers) {
+      const res = await getPlaylistVideos(server.url, server.accessToken, playlistServer1UUID, 0, 10)
+      const videos: Video[] = res.body.data
+
+      expect(videos[0].name).to.equal('video 3 server 1')
+      expect(videos[0].playlistElement.position).to.equal(1)
+      expect(videos[0].playlistElement.startTimestamp).to.equal(1)
+      expect(videos[0].playlistElement.stopTimestamp).to.equal(35)
+
+      expect(videos[5].name).to.equal('video 4 server 1')
+      expect(videos[5].playlistElement.position).to.equal(6)
+      expect(videos[5].playlistElement.startTimestamp).to.equal(45)
+      expect(videos[5].playlistElement.stopTimestamp).to.be.null
+    }
+  })
+
+  it('Should check videos existence in my playlist', async function () {
+    const videoIds = [
+      servers[0].videos[0].id,
+      42000,
+      servers[0].videos[3].id,
+      43000,
+      servers[0].videos[4].id
+    ]
+    const res = await doVideosExistInMyPlaylist(servers[ 0 ].url, servers[ 0 ].accessToken, videoIds)
+    const obj = res.body as VideoExistInPlaylist
+
+    {
+      const elem = obj[servers[0].videos[0].id]
+      expect(elem).to.have.lengthOf(1)
+      expect(elem[ 0 ].playlistId).to.equal(playlistServer1Id)
+      expect(elem[ 0 ].startTimestamp).to.equal(15)
+      expect(elem[ 0 ].stopTimestamp).to.equal(28)
+    }
+
+    {
+      const elem = obj[servers[0].videos[3].id]
+      expect(elem).to.have.lengthOf(1)
+      expect(elem[ 0 ].playlistId).to.equal(playlistServer1Id)
+      expect(elem[ 0 ].startTimestamp).to.equal(1)
+      expect(elem[ 0 ].stopTimestamp).to.equal(35)
+    }
+
+    {
+      const elem = obj[servers[0].videos[4].id]
+      expect(elem).to.have.lengthOf(1)
+      expect(elem[ 0 ].playlistId).to.equal(playlistServer1Id)
+      expect(elem[ 0 ].startTimestamp).to.equal(45)
+      expect(elem[ 0 ].stopTimestamp).to.equal(null)
+    }
+
+    expect(obj[42000]).to.have.lengthOf(0)
+    expect(obj[43000]).to.have.lengthOf(0)
+  })
+
+  it('Should automatically update updatedAt field of playlists', async function () {
+    const server = servers[1]
+    const videoId = servers[1].videos[5].id
+
+    async function getPlaylistNames () {
+      const res = await getAccountPlaylistsListWithToken(server.url, server.accessToken, 'root', 0, 5, undefined, '-updatedAt')
+
+      return (res.body.data as VideoPlaylist[]).map(p => p.displayName)
+    }
+
+    const elementAttrs = { videoId }
+    await addVideoInPlaylist({ url: server.url, token: server.accessToken, playlistId: playlistServer2Id1, elementAttrs })
+    await addVideoInPlaylist({ url: server.url, token: server.accessToken, playlistId: playlistServer2Id2, elementAttrs })
+
+    const names1 = await getPlaylistNames()
+    expect(names1[0]).to.equal('playlist 3 updated')
+    expect(names1[1]).to.equal('playlist 2')
+
+    await removeVideoFromPlaylist({ url: server.url, token: server.accessToken, playlistId: playlistServer2Id1, videoId })
+
+    const names2 = await getPlaylistNames()
+    expect(names2[0]).to.equal('playlist 2')
+    expect(names2[1]).to.equal('playlist 3 updated')
+
+    await removeVideoFromPlaylist({ url: server.url, token: server.accessToken, playlistId: playlistServer2Id2, videoId })
+
+    const names3 = await getPlaylistNames()
+    expect(names3[0]).to.equal('playlist 3 updated')
+    expect(names3[1]).to.equal('playlist 2')
+  })
+
+  it('Should delete some elements', async function () {
+    this.timeout(30000)
+
+    await removeVideoFromPlaylist({
+      url: servers[0].url,
+      token: servers[0].accessToken,
+      playlistId: playlistServer1Id,
+      videoId: servers[0].videos[3].uuid
+    })
+
+    await removeVideoFromPlaylist({
+      url: servers[0].url,
+      token: servers[0].accessToken,
+      playlistId: playlistServer1Id,
+      videoId: nsfwVideoServer1
+    })
+
+    await waitJobs(servers)
+
+    for (const server of servers) {
+      const res = await getPlaylistVideos(server.url, server.accessToken, playlistServer1UUID, 0, 10)
+
+      expect(res.body.total).to.equal(4)
+
+      const videos: Video[] = res.body.data
+      expect(videos).to.have.lengthOf(4)
+
+      expect(videos[ 0 ].name).to.equal('video 0 server 1')
+      expect(videos[ 0 ].playlistElement.position).to.equal(1)
+
+      expect(videos[ 1 ].name).to.equal('video 2 server 3')
+      expect(videos[ 1 ].playlistElement.position).to.equal(2)
+
+      expect(videos[ 2 ].name).to.equal('video 1 server 3')
+      expect(videos[ 2 ].playlistElement.position).to.equal(3)
+
+      expect(videos[ 3 ].name).to.equal('video 4 server 1')
+      expect(videos[ 3 ].playlistElement.position).to.equal(4)
+    }
+  })
+
+  it('Should delete the playlist on server 1 and delete on server 2 and 3', async function () {
+    this.timeout(30000)
+
+    await deleteVideoPlaylist(servers[0].url, servers[0].accessToken, playlistServer1Id)
+
+    await waitJobs(servers)
+
+    for (const server of servers) {
+      await getVideoPlaylist(server.url, playlistServer1UUID, 404)
+    }
+  })
+
+  it('Should have deleted the thumbnail on server 1, 2 and 3', async function () {
+    this.timeout(30000)
+
+    for (const server of servers) {
+      await checkPlaylistFilesWereRemoved(playlistServer1UUID, server.serverNumber)
+    }
+  })
+
+  it('Should unfollow servers 1 and 2 and hide their playlists', async function () {
+    this.timeout(30000)
+
+    const finder = data => data.find(p => p.displayName === 'my super playlist')
+
+    {
+      const res = await getVideoPlaylistsList(servers[ 2 ].url, 0, 5)
+      expect(res.body.total).to.equal(2)
+      expect(finder(res.body.data)).to.not.be.undefined
+    }
+
+    await unfollow(servers[2].url, servers[2].accessToken, servers[0])
+
+    {
+      const res = await getVideoPlaylistsList(servers[ 2 ].url, 0, 5)
+      expect(res.body.total).to.equal(1)
+
+      expect(finder(res.body.data)).to.be.undefined
+    }
+  })
+
+  it('Should delete a channel and put the associated playlist in private mode', async function () {
+    this.timeout(30000)
+
+    const res = await addVideoChannel(servers[0].url, servers[0].accessToken, { name: 'super_channel', displayName: 'super channel' })
+    const videoChannelId = res.body.videoChannel.id
+
+    const res2 = await createVideoPlaylist({
+      url: servers[0].url,
+      token: servers[0].accessToken,
+      playlistAttrs: {
+        displayName: 'channel playlist',
+        privacy: VideoPlaylistPrivacy.PUBLIC,
+        videoChannelId
+      }
+    })
+    const videoPlaylistUUID = res2.body.videoPlaylist.uuid
+
+    await waitJobs(servers)
+
+    await deleteVideoChannel(servers[0].url, servers[0].accessToken, 'super_channel')
+
+    await waitJobs(servers)
+
+    const res3 = await getVideoPlaylistWithToken(servers[0].url, servers[0].accessToken, videoPlaylistUUID)
+    expect(res3.body.displayName).to.equal('channel playlist')
+    expect(res3.body.privacy.id).to.equal(VideoPlaylistPrivacy.PRIVATE)
+
+    await getVideoPlaylist(servers[1].url, videoPlaylistUUID, 404)
+  })
+
+  it('Should delete an account and delete its playlists', async function () {
+    this.timeout(30000)
+
+    const user = { username: 'user_1', password: 'password' }
+    const res = await createUser({
+      url: servers[ 0 ].url,
+      accessToken: servers[ 0 ].accessToken,
+      username: user.username,
+      password: user.password
+    })
+
+    const userId = res.body.user.id
+    const userAccessToken = await userLogin(servers[0], user)
+
+    const resChannel = await getMyUserInformation(servers[0].url, userAccessToken)
+    const userChannel = (resChannel.body as User).videoChannels[0]
+
+    await createVideoPlaylist({
+      url: servers[0].url,
+      token: userAccessToken,
+      playlistAttrs: {
+        displayName: 'playlist to be deleted',
+        privacy: VideoPlaylistPrivacy.PUBLIC,
+        videoChannelId: userChannel.id
+      }
+    })
+
+    await waitJobs(servers)
+
+    const finder = data => data.find(p => p.displayName === 'playlist to be deleted')
+
+    {
+      for (const server of [ servers[0], servers[1] ]) {
+        const res = await getVideoPlaylistsList(server.url, 0, 15)
+        expect(finder(res.body.data)).to.not.be.undefined
+      }
+    }
+
+    await removeUser(servers[0].url, userId, servers[0].accessToken)
+    await waitJobs(servers)
+
+    {
+      for (const server of [ servers[0], servers[1] ]) {
+        const res = await getVideoPlaylistsList(server.url, 0, 15)
+        expect(finder(res.body.data)).to.be.undefined
+      }
+    }
+  })
+
+  after(async function () {
+    await cleanupTests(servers)
+  })
+})
diff --git a/server/tests/api/videos/video-privacy.ts b/server/tests/api/videos/video-privacy.ts
index 0b4e66369..ef1cf0f07 100644
--- a/server/tests/api/videos/video-privacy.ts
+++ b/server/tests/api/videos/video-privacy.ts
@@ -4,18 +4,19 @@ import * as chai from 'chai'
 import 'mocha'
 import { VideoPrivacy } from '../../../../shared/models/videos/video-privacy.enum'
 import {
+  cleanupTests,
   flushAndRunMultipleServers,
   getVideosList,
   killallServers,
   ServerInfo,
   setAccessTokensToServers,
   uploadVideo
-} from '../../../../shared/utils/index'
-import { doubleFollow } from '../../../../shared/utils/server/follows'
-import { userLogin } from '../../../../shared/utils/users/login'
-import { createUser } from '../../../../shared/utils/users/users'
-import { getMyVideos, getVideo, getVideoWithToken, updateVideo } from '../../../../shared/utils/videos/videos'
-import { waitJobs } from '../../../../shared/utils/server/jobs'
+} from '../../../../shared/extra-utils/index'
+import { doubleFollow } from '../../../../shared/extra-utils/server/follows'
+import { userLogin } from '../../../../shared/extra-utils/users/login'
+import { createUser } from '../../../../shared/extra-utils/users/users'
+import { getMyVideos, getVideo, getVideoWithToken, updateVideo } from '../../../../shared/extra-utils/videos/videos'
+import { waitJobs } from '../../../../shared/extra-utils/server/jobs'
 
 const expect = chai.expect
 
@@ -78,7 +79,7 @@ describe('Test video privacy', function () {
       username: 'hello',
       password: 'super password'
     }
-    await createUser(servers[0].url, servers[0].accessToken, user.username, user.password)
+    await createUser({ url: servers[ 0 ].url, accessToken: servers[ 0 ].accessToken, username: user.username, password: user.password })
 
     const token = await userLogin(servers[0], user)
     await getVideoWithToken(servers[0].url, token, privateVideoUUID, 403)
@@ -153,6 +154,6 @@ describe('Test video privacy', function () {
   })
 
   after(async function () {
-    killallServers(servers)
+    await cleanupTests(servers)
   })
 })
diff --git a/server/tests/api/videos/video-schedule-update.ts b/server/tests/api/videos/video-schedule-update.ts
index 632c4244c..64f657780 100644
--- a/server/tests/api/videos/video-schedule-update.ts
+++ b/server/tests/api/videos/video-schedule-update.ts
@@ -4,6 +4,7 @@ import * as chai from 'chai'
 import 'mocha'
 import { VideoPrivacy } from '../../../../shared/models/videos'
 import {
+  cleanupTests,
   doubleFollow,
   flushAndRunMultipleServers,
   getMyVideos,
@@ -15,8 +16,8 @@ import {
   updateVideo,
   uploadVideo,
   wait
-} from '../../../../shared/utils'
-import { waitJobs } from '../../../../shared/utils/server/jobs'
+} from '../../../../shared/extra-utils'
+import { waitJobs } from '../../../../shared/extra-utils/server/jobs'
 
 const expect = chai.expect
 
@@ -166,6 +167,6 @@ describe('Test video update scheduler', function () {
   })
 
   after(async function () {
-    killallServers(servers)
+    await cleanupTests(servers)
   })
 })
diff --git a/server/tests/api/videos/video-transcoder.ts b/server/tests/api/videos/video-transcoder.ts
index eefd32ef8..3cd43e99b 100644
--- a/server/tests/api/videos/video-transcoder.ts
+++ b/server/tests/api/videos/video-transcoder.ts
@@ -6,7 +6,7 @@ import { omit } from 'lodash'
 import { getMaxBitrate, VideoDetails, VideoResolution, VideoState } from '../../../../shared/models/videos'
 import { audio, getVideoFileBitrate, getVideoFileFPS, getVideoFileResolution } from '../../../helpers/ffmpeg-utils'
 import {
-  buildAbsoluteFixturePath,
+  buildAbsoluteFixturePath, cleanupTests,
   doubleFollow,
   flushAndRunMultipleServers,
   generateHighBitrateVideo,
@@ -19,9 +19,9 @@ import {
   setAccessTokensToServers,
   uploadVideo,
   webtorrentAdd
-} from '../../../../shared/utils'
+} from '../../../../shared/extra-utils'
 import { extname, join } from 'path'
-import { waitJobs } from '../../../../shared/utils/server/jobs'
+import { waitJobs } from '../../../../shared/extra-utils/server/jobs'
 import { VIDEO_TRANSCODING_FPS } from '../../../../server/initializers/constants'
 
 const expect = chai.expect
@@ -350,6 +350,6 @@ describe('Test video transcoding', function () {
   })
 
   after(async function () {
-    killallServers(servers)
+    await cleanupTests(servers)
   })
 })
diff --git a/server/tests/api/videos/videos-filter.ts b/server/tests/api/videos/videos-filter.ts
index 59e37ad86..e1e65260f 100644
--- a/server/tests/api/videos/videos-filter.ts
+++ b/server/tests/api/videos/videos-filter.ts
@@ -3,6 +3,7 @@
 import * as chai from 'chai'
 import 'mocha'
 import {
+  cleanupTests,
   createUser,
   doubleFollow,
   flushAndRunMultipleServers,
@@ -13,7 +14,7 @@ import {
   setAccessTokensToServers,
   uploadVideo,
   userLogin
-} from '../../../../shared/utils'
+} from '../../../../shared/extra-utils'
 import { Video, VideoPrivacy } from '../../../../shared/models/videos'
 import { UserRole } from '../../../../shared/models/users'
 
@@ -55,8 +56,6 @@ describe('Test videos filter validator', function () {
   before(async function () {
     this.timeout(120000)
 
-    await flushTests()
-
     servers = await flushAndRunMultipleServers(2)
 
     await setAccessTokensToServers(servers)
@@ -64,13 +63,15 @@ describe('Test videos filter validator', function () {
     for (const server of servers) {
       const moderator = { username: 'moderator', password: 'my super password' }
       await createUser(
-        server.url,
-        server.accessToken,
-        moderator.username,
-        moderator.password,
-        undefined,
-        undefined,
-        UserRole.MODERATOR
+        {
+          url: server.url,
+          accessToken: server.accessToken,
+          username: moderator.username,
+          password: moderator.password,
+          videoQuota: undefined,
+          videoQuotaDaily: undefined,
+          role: UserRole.MODERATOR
+        }
       )
       server['moderatorAccessToken'] = await userLogin(server, moderator)
 
@@ -120,11 +121,6 @@ describe('Test videos filter validator', function () {
   })
 
   after(async function () {
-    killallServers(servers)
-
-    // Keep the logs if the test failed
-    if (this['ok']) {
-      await flushTests()
-    }
+    await cleanupTests(servers)
   })
 })
diff --git a/server/tests/api/videos/videos-history.ts b/server/tests/api/videos/videos-history.ts
index f654a422b..c7e55c1ab 100644
--- a/server/tests/api/videos/videos-history.ts
+++ b/server/tests/api/videos/videos-history.ts
@@ -3,21 +3,23 @@
 import * as chai from 'chai'
 import 'mocha'
 import {
+  cleanupTests,
   createUser,
-  flushTests,
+  flushAndRunServer,
   getVideosListWithToken,
   getVideoWithToken,
   killallServers,
-  runServer,
+  reRunServer,
   searchVideoWithToken,
   ServerInfo,
   setAccessTokensToServers,
   updateMyUser,
   uploadVideo,
-  userLogin
-} from '../../../../shared/utils'
+  userLogin,
+  wait
+} from '../../../../shared/extra-utils'
 import { Video, VideoDetails } from '../../../../shared/models/videos'
-import { listMyVideosHistory, removeMyVideosHistory, userWatchVideo } from '../../../../shared/utils/videos/video-history'
+import { listMyVideosHistory, removeMyVideosHistory, userWatchVideo } from '../../../../shared/extra-utils/videos/video-history'
 
 const expect = chai.expect
 
@@ -32,9 +34,7 @@ describe('Test videos history', function () {
   before(async function () {
     this.timeout(30000)
 
-    await flushTests()
-
-    server = await runServer(1)
+    server = await flushAndRunServer(1)
 
     await setAccessTokensToServers([ server ])
 
@@ -57,7 +57,7 @@ describe('Test videos history', function () {
       username: 'user_1',
       password: 'super password'
     }
-    await createUser(server.url, server.accessToken, user.username, user.password)
+    await createUser({ url: server.url, accessToken: server.accessToken, username: user.username, password: user.password })
     userAccessToken = await userLogin(server, user)
   })
 
@@ -192,12 +192,36 @@ describe('Test videos history', function () {
     expect(videos[1].name).to.equal('video 3')
   })
 
-  after(async function () {
+  it('Should not clean old history', async function () {
+    this.timeout(50000)
+
     killallServers([ server ])
 
-    // Keep the logs if the test failed
-    if (this['ok']) {
-      await flushTests()
-    }
+    await reRunServer(server, { history: { videos: { max_age: '10 days' } } })
+
+    await wait(6000)
+
+    // Should still have history
+
+    const res = await listMyVideosHistory(server.url, server.accessToken)
+
+    expect(res.body.total).to.equal(2)
+  })
+
+  it('Should clean old history', async function () {
+    this.timeout(50000)
+
+    killallServers([ server ])
+
+    await reRunServer(server, { history: { videos: { max_age: '5 seconds' } } })
+
+    await wait(6000)
+
+    const res = await listMyVideosHistory(server.url, server.accessToken)
+    expect(res.body.total).to.equal(0)
+  })
+
+  after(async function () {
+    await cleanupTests([ server ])
   })
 })
diff --git a/server/tests/api/videos/videos-overview.ts b/server/tests/api/videos/videos-overview.ts
index 7221bcae6..975a5c87a 100644
--- a/server/tests/api/videos/videos-overview.ts
+++ b/server/tests/api/videos/videos-overview.ts
@@ -2,8 +2,8 @@
 
 import * as chai from 'chai'
 import 'mocha'
-import { flushTests, killallServers, runServer, ServerInfo, setAccessTokensToServers, uploadVideo } from '../../../../shared/utils'
-import { getVideosOverview } from '../../../../shared/utils/overviews/overviews'
+import { cleanupTests, flushAndRunServer, ServerInfo, setAccessTokensToServers, uploadVideo } from '../../../../shared/extra-utils'
+import { getVideosOverview } from '../../../../shared/extra-utils/overviews/overviews'
 import { VideosOverview } from '../../../../shared/models/overviews'
 
 const expect = chai.expect
@@ -14,9 +14,7 @@ describe('Test a videos overview', function () {
   before(async function () {
     this.timeout(30000)
 
-    await flushTests()
-
-    server = await runServer(1)
+    server = await flushAndRunServer(1)
 
     await setAccessTokensToServers([ server ])
   })
@@ -90,11 +88,6 @@ describe('Test a videos overview', function () {
   })
 
   after(async function () {
-    killallServers([ server ])
-
-    // Keep the logs if the test failed
-    if (this['ok']) {
-      await flushTests()
-    }
+    await cleanupTests([ server ])
   })
 })
diff --git a/server/tests/api/videos/videos-views-cleaner.ts b/server/tests/api/videos/videos-views-cleaner.ts
new file mode 100644
index 000000000..c21d46d56
--- /dev/null
+++ b/server/tests/api/videos/videos-views-cleaner.ts
@@ -0,0 +1,106 @@
+/* tslint:disable:no-unused-expression */
+
+import * as chai from 'chai'
+import 'mocha'
+import {
+  flushAndRunMultipleServers,
+  flushTests,
+  killallServers,
+  reRunServer,
+  flushAndRunServer,
+  ServerInfo,
+  setAccessTokensToServers,
+  uploadVideo, uploadVideoAndGetId, viewVideo, wait, countVideoViewsOf, doubleFollow, waitJobs, cleanupTests
+} from '../../../../shared/extra-utils'
+import { getVideosOverview } from '../../../../shared/extra-utils/overviews/overviews'
+import { VideosOverview } from '../../../../shared/models/overviews'
+import { listMyVideosHistory } from '../../../../shared/extra-utils/videos/video-history'
+
+const expect = chai.expect
+
+describe('Test video views cleaner', function () {
+  let servers: ServerInfo[]
+
+  let videoIdServer1: string
+  let videoIdServer2: string
+
+  before(async function () {
+    this.timeout(50000)
+
+    servers = await flushAndRunMultipleServers(2)
+    await setAccessTokensToServers(servers)
+
+    await doubleFollow(servers[0], servers[1])
+
+    videoIdServer1 = (await uploadVideoAndGetId({ server: servers[0], videoName: 'video server 1' })).uuid
+    videoIdServer2 = (await uploadVideoAndGetId({ server: servers[1], videoName: 'video server 2' })).uuid
+
+    await waitJobs(servers)
+
+    await viewVideo(servers[0].url, videoIdServer1)
+    await viewVideo(servers[1].url, videoIdServer1)
+    await viewVideo(servers[0].url, videoIdServer2)
+    await viewVideo(servers[1].url, videoIdServer2)
+
+    await waitJobs(servers)
+  })
+
+  it('Should not clean old video views', async function () {
+    this.timeout(50000)
+
+    killallServers([ servers[0] ])
+
+    await reRunServer(servers[0], { views: { videos: { remote: { max_age: '10 days' } } } })
+
+    await wait(6000)
+
+    // Should still have views
+
+    {
+      for (const server of servers) {
+        const total = await countVideoViewsOf(server.serverNumber, videoIdServer1)
+        expect(total).to.equal(2)
+      }
+    }
+
+    {
+      for (const server of servers) {
+        const total = await countVideoViewsOf(server.serverNumber, videoIdServer2)
+        expect(total).to.equal(2)
+      }
+    }
+  })
+
+  it('Should clean old video views', async function () {
+    this.timeout(50000)
+
+    this.timeout(50000)
+
+    killallServers([ servers[0] ])
+
+    await reRunServer(servers[0], { views: { videos: { remote: { max_age: '5 seconds' } } } })
+
+    await wait(6000)
+
+    // Should still have views
+
+    {
+      for (const server of servers) {
+        const total = await countVideoViewsOf(server.serverNumber, videoIdServer1)
+        expect(total).to.equal(2)
+      }
+    }
+
+    {
+      const totalServer1 = await countVideoViewsOf(servers[0].serverNumber, videoIdServer2)
+      expect(totalServer1).to.equal(0)
+
+      const totalServer2 = await countVideoViewsOf(servers[1].serverNumber, videoIdServer2)
+      expect(totalServer2).to.equal(2)
+    }
+  })
+
+  after(async function () {
+    await cleanupTests(servers)
+  })
+})
diff --git a/server/tests/cli/create-import-video-file-job.ts b/server/tests/cli/create-import-video-file-job.ts
index 4acda47b1..0d378c1aa 100644
--- a/server/tests/cli/create-import-video-file-job.ts
+++ b/server/tests/cli/create-import-video-file-job.ts
@@ -4,6 +4,7 @@ import 'mocha'
 import * as chai from 'chai'
 import { VideoDetails, VideoFile } from '../../../shared/models/videos'
 import {
+  cleanupTests,
   doubleFollow,
   execCLI,
   flushAndRunMultipleServers,
@@ -15,8 +16,8 @@ import {
   ServerInfo,
   setAccessTokensToServers,
   uploadVideo
-} from '../../../shared/utils'
-import { waitJobs } from '../../../shared/utils/server/jobs'
+} from '../../../shared/extra-utils'
+import { waitJobs } from '../../../shared/extra-utils/server/jobs'
 
 const expect = chai.expect
 
@@ -39,7 +40,6 @@ describe('Test create import video jobs', function () {
 
   before(async function () {
     this.timeout(90000)
-    await flushTests()
 
     // Run server 2 to have transcoding enabled
     servers = await flushAndRunMultipleServers(2)
@@ -132,6 +132,6 @@ describe('Test create import video jobs', function () {
   })
 
   after(async function () {
-    killallServers(servers)
+    await cleanupTests(servers)
   })
 })
diff --git a/server/tests/cli/create-transcoding-job.ts b/server/tests/cli/create-transcoding-job.ts
index 50be5fa19..1c0e10066 100644
--- a/server/tests/cli/create-transcoding-job.ts
+++ b/server/tests/cli/create-transcoding-job.ts
@@ -4,6 +4,7 @@ import 'mocha'
 import * as chai from 'chai'
 import { VideoDetails } from '../../../shared/models/videos'
 import {
+  cleanupTests,
   doubleFollow,
   execCLI,
   flushAndRunMultipleServers,
@@ -15,8 +16,8 @@ import {
   ServerInfo,
   setAccessTokensToServers,
   uploadVideo, wait
-} from '../../../shared/utils'
-import { waitJobs } from '../../../shared/utils/server/jobs'
+} from '../../../shared/extra-utils'
+import { waitJobs } from '../../../shared/extra-utils/server/jobs'
 
 const expect = chai.expect
 
@@ -28,8 +29,6 @@ describe('Test create transcoding jobs', function () {
   before(async function () {
     this.timeout(60000)
 
-    await flushTests()
-
     // Run server 2 to have transcoding enabled
     servers = await flushAndRunMultipleServers(2)
     await setAccessTokensToServers(servers)
@@ -127,6 +126,6 @@ describe('Test create transcoding jobs', function () {
   })
 
   after(async function () {
-    killallServers(servers)
+    await cleanupTests(servers)
   })
 })
diff --git a/server/tests/cli/optimize-old-videos.ts b/server/tests/cli/optimize-old-videos.ts
index 6f6bc25a6..5e12c0089 100644
--- a/server/tests/cli/optimize-old-videos.ts
+++ b/server/tests/cli/optimize-old-videos.ts
@@ -4,6 +4,7 @@ import 'mocha'
 import * as chai from 'chai'
 import { getMaxBitrate, Video, VideoDetails, VideoResolution } from '../../../shared/models/videos'
 import {
+  cleanupTests,
   doubleFollow,
   execCLI,
   flushAndRunMultipleServers,
@@ -15,10 +16,10 @@ import {
   ServerInfo,
   setAccessTokensToServers,
   uploadVideo, viewVideo, wait
-} from '../../../shared/utils'
-import { waitJobs } from '../../../shared/utils/server/jobs'
+} from '../../../shared/extra-utils'
+import { waitJobs } from '../../../shared/extra-utils/server/jobs'
 import { getVideoFileBitrate, getVideoFileFPS, getVideoFileResolution } from '../../helpers/ffmpeg-utils'
-import { VIDEO_TRANSCODING_FPS } from '../../initializers'
+import { VIDEO_TRANSCODING_FPS } from '../../initializers/constants'
 import { join } from 'path'
 
 const expect = chai.expect
@@ -31,8 +32,6 @@ describe('Test optimize old videos', function () {
   before(async function () {
     this.timeout(200000)
 
-    await flushTests()
-
     // Run server 2 to have transcoding enabled
     servers = await flushAndRunMultipleServers(2)
     await setAccessTokensToServers(servers)
@@ -115,6 +114,6 @@ describe('Test optimize old videos', function () {
   })
 
   after(async function () {
-    killallServers(servers)
+    await cleanupTests(servers)
   })
 })
diff --git a/server/tests/cli/peertube.ts b/server/tests/cli/peertube.ts
index e2836d0c3..80bbc98d5 100644
--- a/server/tests/cli/peertube.ts
+++ b/server/tests/cli/peertube.ts
@@ -8,10 +8,10 @@ import {
   flushTests,
   getEnvCli,
   killallServers,
-  runServer,
+  flushAndRunServer,
   ServerInfo,
-  setAccessTokensToServers
-} from '../../../shared/utils'
+  setAccessTokensToServers, cleanupTests
+} from '../../../shared/extra-utils'
 
 describe('Test CLI wrapper', function () {
   let server: ServerInfo
@@ -19,12 +19,10 @@ describe('Test CLI wrapper', function () {
 
   before(async function () {
     this.timeout(30000)
-
-    await flushTests()
-    server = await runServer(1)
+    server = await flushAndRunServer(1)
     await setAccessTokensToServers([ server ])
 
-    await createUser(server.url, server.accessToken, 'user_1', 'super password')
+    await createUser({ url: server.url, accessToken: server.accessToken, username: 'user_1', password: 'super password' })
   })
 
   it('Should display no selected instance', async function () {
@@ -48,6 +46,6 @@ describe('Test CLI wrapper', function () {
 
     await execCLI(cmd + ` auth del ${server.url}`)
 
-    killallServers([ server ])
+    await cleanupTests([ server ])
   })
 })
diff --git a/server/tests/cli/reset-password.ts b/server/tests/cli/reset-password.ts
index 1b65f7e39..6abb6738f 100644
--- a/server/tests/cli/reset-password.ts
+++ b/server/tests/cli/reset-password.ts
@@ -1,28 +1,25 @@
 import 'mocha'
 
 import {
+  cleanupTests,
   createUser,
   execCLI,
-  flushTests,
+  flushAndRunServer,
   getEnvCli,
-  killallServers,
   login,
-  runServer,
   ServerInfo,
   setAccessTokensToServers
-} from '../../../shared/utils'
+} from '../../../shared/extra-utils'
 
 describe('Test reset password scripts', function () {
   let server: ServerInfo
 
   before(async function () {
     this.timeout(30000)
-
-    await flushTests()
-    server = await runServer(1)
+    server = await flushAndRunServer(1)
     await setAccessTokensToServers([ server ])
 
-    await createUser(server.url, server.accessToken, 'user_1', 'super password')
+    await createUser({ url: server.url, accessToken: server.accessToken, username: 'user_1', password: 'super password' })
   })
 
   it('Should change the user password from CLI', async function () {
@@ -35,6 +32,6 @@ describe('Test reset password scripts', function () {
   })
 
   after(async function () {
-    killallServers([ server ])
+    await cleanupTests([ server ])
   })
 })
diff --git a/server/tests/cli/update-host.ts b/server/tests/cli/update-host.ts
index 811ea6a9f..55c43b32f 100644
--- a/server/tests/cli/update-host.ts
+++ b/server/tests/cli/update-host.ts
@@ -3,26 +3,26 @@
 import 'mocha'
 import * as chai from 'chai'
 import { VideoDetails } from '../../../shared/models/videos'
-import { waitJobs } from '../../../shared/utils/server/jobs'
-import { addVideoCommentThread } from '../../../shared/utils/videos/video-comments'
+import { waitJobs } from '../../../shared/extra-utils/server/jobs'
+import { addVideoCommentThread } from '../../../shared/extra-utils/videos/video-comments'
 import {
   addVideoChannel,
+  cleanupTests,
   createUser,
   execCLI,
-  flushTests,
+  flushAndRunServer,
   getEnvCli,
   getVideo,
   getVideoChannelsList,
   getVideosList,
   killallServers,
   makeActivityPubGetRequest,
-  parseTorrentVideo,
-  runServer,
+  parseTorrentVideo, reRunServer,
   ServerInfo,
   setAccessTokensToServers,
   uploadVideo
-} from '../../../shared/utils'
-import { getAccountsList } from '../../../shared/utils/users/accounts'
+} from '../../../shared/extra-utils'
+import { getAccountsList } from '../../../shared/extra-utils/users/accounts'
 
 const expect = chai.expect
 
@@ -32,15 +32,13 @@ describe('Test update host scripts', function () {
   before(async function () {
     this.timeout(60000)
 
-    await flushTests()
-
     const overrideConfig = {
       webserver: {
         port: 9256
       }
     }
     // Run server 2 to have transcoding enabled
-    server = await runServer(2, overrideConfig)
+    server = await flushAndRunServer(2, overrideConfig)
     await setAccessTokensToServers([ server ])
 
     // Upload two videos for our needs
@@ -50,7 +48,7 @@ describe('Test update host scripts', function () {
     await uploadVideo(server.url, server.accessToken, videoAttributes)
 
     // Create a user
-    await createUser(server.url, server.accessToken, 'toto', 'coucou')
+    await createUser({ url: server.url, accessToken: server.accessToken, username: 'toto', password: 'coucou' })
 
     // Create channel
     const videoChannel = {
@@ -72,7 +70,7 @@ describe('Test update host scripts', function () {
 
     killallServers([ server ])
     // Run server with standard configuration
-    server = await runServer(2)
+    await reRunServer(server)
 
     const env = getEnvCli(server)
     await execCLI(`${env} npm run update-host`)
@@ -86,6 +84,13 @@ describe('Test update host scripts', function () {
       const { body } = await makeActivityPubGetRequest(server.url, '/videos/watch/' + video.uuid)
 
       expect(body.id).to.equal('http://localhost:9002/videos/watch/' + video.uuid)
+
+      const res = await getVideo(server.url, video.uuid)
+      const videoDetails: VideoDetails = res.body
+
+      expect(videoDetails.trackerUrls[0]).to.include(server.host)
+      expect(videoDetails.streamingPlaylists[0].playlistUrl).to.include(server.host)
+      expect(videoDetails.streamingPlaylists[0].segmentsSha256Url).to.include(server.host)
     }
   })
 
@@ -100,7 +105,7 @@ describe('Test update host scripts', function () {
     }
   })
 
-  it('Should have update accounts url', async function () {
+  it('Should have updated accounts url', async function () {
     const res = await getAccountsList(server.url)
     expect(res.body.total).to.equal(3)
 
@@ -112,7 +117,7 @@ describe('Test update host scripts', function () {
     }
   })
 
-  it('Should update torrent hosts', async function () {
+  it('Should have updated torrent hosts', async function () {
     this.timeout(30000)
 
     const res = await getVideosList(server.url)
@@ -142,6 +147,6 @@ describe('Test update host scripts', function () {
   })
 
   after(async function () {
-    killallServers([ server ])
+    await cleanupTests([ server ])
   })
 })
diff --git a/server/tests/client.ts b/server/tests/client.ts
index 06b4a9c5a..778dcd08e 100644
--- a/server/tests/client.ts
+++ b/server/tests/client.ts
@@ -4,18 +4,17 @@ import 'mocha'
 import * as chai from 'chai'
 import * as request from 'supertest'
 import {
-  flushTests,
+  cleanupTests,
+  flushAndRunServer,
   getCustomConfig,
   getVideosList,
-  killallServers,
   makeHTMLRequest,
-  runServer,
   ServerInfo,
   serverLogin,
   updateCustomConfig,
   updateCustomSubConfig,
   uploadVideo
-} from '../../shared/utils'
+} from '../../shared/extra-utils'
 
 const expect = chai.expect
 
@@ -31,9 +30,7 @@ describe('Test a client controllers', function () {
   before(async function () {
     this.timeout(120000)
 
-    await flushTests()
-
-    server = await runServer(1)
+    server = await flushAndRunServer(1)
     server.accessToken = await serverLogin(server)
 
     const videoAttributes = {
@@ -148,6 +145,6 @@ describe('Test a client controllers', function () {
   })
 
   after(async function () {
-    killallServers([ server ])
+    await cleanupTests([ server ])
   })
 })
diff --git a/server/tests/feeds/feeds.ts b/server/tests/feeds/feeds.ts
index a771474bc..0dcdf09cf 100644
--- a/server/tests/feeds/feeds.ts
+++ b/server/tests/feeds/feeds.ts
@@ -3,6 +3,7 @@
 import * as chai from 'chai'
 import 'mocha'
 import {
+  cleanupTests,
   createUser,
   doubleFollow,
   flushAndRunMultipleServers,
@@ -13,10 +14,10 @@ import {
   ServerInfo,
   setAccessTokensToServers,
   uploadVideo, userLogin
-} from '../../../shared/utils'
+} from '../../../shared/extra-utils'
 import * as libxmljs from 'libxmljs'
-import { addVideoCommentThread } from '../../../shared/utils/videos/video-comments'
-import { waitJobs } from '../../../shared/utils/server/jobs'
+import { addVideoCommentThread } from '../../../shared/extra-utils/videos/video-comments'
+import { waitJobs } from '../../../shared/extra-utils/server/jobs'
 import { User } from '../../../shared/models/users'
 
 chai.use(require('chai-xml'))
@@ -50,7 +51,7 @@ describe('Test syndication feeds', () => {
 
     {
       const attr = { username: 'john', password: 'password' }
-      await createUser(servers[0].url, servers[0].accessToken, attr.username, attr.password)
+      await createUser({ url: servers[ 0 ].url, accessToken: servers[ 0 ].accessToken, username: attr.username, password: attr.password })
       userAccessToken = await userLogin(servers[0], attr)
 
       const res = await getMyUserInformation(servers[0].url, userAccessToken)
@@ -208,11 +209,6 @@ describe('Test syndication feeds', () => {
   })
 
   after(async function () {
-    killallServers(servers)
-
-    // Keep the logs if the test failed
-    if (this['ok']) {
-      await flushTests()
-    }
+    await cleanupTests(servers)
   })
 })
diff --git a/server/tests/fixtures/thumbnail-playlist.jpg b/server/tests/fixtures/thumbnail-playlist.jpg
new file mode 100644
index 000000000..19db4f18c
--- /dev/null
+++ b/server/tests/fixtures/thumbnail-playlist.jpg
diff --git a/server/tests/helpers/index.ts b/server/tests/helpers/index.ts
index 551208245..03b971770 100644
--- a/server/tests/helpers/index.ts
+++ b/server/tests/helpers/index.ts
@@ -1,2 +1,3 @@
 import './core-utils'
 import './comment-model'
+import './request'
diff --git a/server/tests/helpers/request.ts b/server/tests/helpers/request.ts
new file mode 100644
index 000000000..a754bc6e2
--- /dev/null
+++ b/server/tests/helpers/request.ts
@@ -0,0 +1,48 @@
+/* tslint:disable:no-unused-expression */
+
+import 'mocha'
+import { doRequest, doRequestAndSaveToFile } from '../../helpers/requests'
+import { get4KFileUrl, root, wait } from '../../../shared/extra-utils'
+import { join } from 'path'
+import { pathExists, remove } from 'fs-extra'
+import { expect } from 'chai'
+
+describe('Request helpers', function () {
+  const destPath1 = join(root(), 'test-output-1.txt')
+  const destPath2 = join(root(), 'test-output-2.txt')
+
+  it('Should throw an error when the bytes limit is exceeded for request', async function () {
+    try {
+      await doRequest({ uri: get4KFileUrl() }, 3)
+    } catch {
+      return
+    }
+
+    throw new Error('No error thrown by do request')
+  })
+
+  it('Should throw an error when the bytes limit is exceeded for request and save file', async function () {
+    try {
+      await doRequestAndSaveToFile({ uri: get4KFileUrl() }, destPath1, 3)
+    } catch {
+
+      await wait(500)
+      expect(await pathExists(destPath1)).to.be.false
+      return
+    }
+
+    throw new Error('No error thrown by do request and save to file')
+  })
+
+  it('Should succeed if the file is below the limit', async function () {
+    await doRequest({ uri: get4KFileUrl() }, 5)
+    await doRequestAndSaveToFile({ uri: get4KFileUrl() }, destPath2, 5)
+
+    expect(await pathExists(destPath2)).to.be.true
+  })
+
+  after(async function () {
+    await remove(destPath1)
+    await remove(destPath2)
+  })
+})
diff --git a/server/tests/misc-endpoints.ts b/server/tests/misc-endpoints.ts
index 5f82719da..ed406e1bc 100644
--- a/server/tests/misc-endpoints.ts
+++ b/server/tests/misc-endpoints.ts
@@ -4,15 +4,14 @@ import 'mocha'
 import * as chai from 'chai'
 import {
   addVideoChannel,
+  cleanupTests,
   createUser,
-  flushTests,
-  killallServers,
+  flushAndRunServer,
   makeGetRequest,
-  runServer,
   ServerInfo,
   setAccessTokensToServers,
   uploadVideo
-} from '../../shared/utils'
+} from '../../shared/extra-utils'
 import { VideoPrivacy } from '../../shared/models/videos'
 
 const expect = chai.expect
@@ -23,9 +22,7 @@ describe('Test misc endpoints', function () {
   before(async function () {
     this.timeout(120000)
 
-    await flushTests()
-
-    server = await runServer(1)
+    server = await flushAndRunServer(1)
     await setAccessTokensToServers([ server ])
   })
 
@@ -149,8 +146,8 @@ describe('Test misc endpoints', function () {
       await addVideoChannel(server.url, server.accessToken, { name: 'channel1', displayName: 'channel 1' })
       await addVideoChannel(server.url, server.accessToken, { name: 'channel2', displayName: 'channel 2' })
 
-      await createUser(server.url, server.accessToken, 'user1', 'password')
-      await createUser(server.url, server.accessToken, 'user2', 'password')
+      await createUser({ url: server.url, accessToken: server.accessToken, username: 'user1', password: 'password' })
+      await createUser({ url: server.url, accessToken: server.accessToken, username: 'user2', password: 'password' })
 
       const res = await makeGetRequest({
         url: server.url,
@@ -174,6 +171,6 @@ describe('Test misc endpoints', function () {
   })
 
   after(async function () {
-    killallServers([ server ])
+    await cleanupTests([ server ])
   })
 })
diff --git a/server/tests/real-world/populate-database.ts b/server/tests/real-world/populate-database.ts
index 016503498..b1c1688e7 100644
--- a/server/tests/real-world/populate-database.ts
+++ b/server/tests/real-world/populate-database.ts
@@ -6,11 +6,11 @@ import {
   getVideosList,
   killallServers,
   rateVideo,
-  runServer,
+  flushAndRunServer,
   ServerInfo,
   setAccessTokensToServers,
   uploadVideo
-} from '../../../shared/utils'
+} from '../../../shared/extra-utils'
 import * as Bluebird from 'bluebird'
 
 start()
@@ -19,11 +19,10 @@ start()
 // ----------------------------------------------------------------------------
 
 async function start () {
-  await flushTests()
 
   console.log('Flushed tests.')
 
-  const server = await runServer(6)
+  const server = await flushAndRunServer(6)
 
   process.on('exit', async () => {
     killallServers([ server ])
@@ -78,7 +77,7 @@ function createUserCustom (server: ServerInfo) {
   const username = Date.now().toString() + getRandomInt(0, 100000)
   console.log('Creating user %s.', username)
 
-  return createUser(server.url, server.accessToken, username, 'coucou')
+  return createUser({ url: server.url, accessToken: server.accessToken, username: username, password: 'coucou' })
 }
 
 function uploadCustom (server: ServerInfo) {
diff --git a/server/tests/real-world/real-world.ts b/server/tests/real-world/real-world.ts
index ac3baaf9a..8b070004d 100644
--- a/server/tests/real-world/real-world.ts
+++ b/server/tests/real-world/real-world.ts
@@ -16,8 +16,8 @@ import {
   updateVideo,
   uploadVideo, viewVideo,
   wait
-} from '../../../shared/utils'
-import { getJobsListPaginationAndSort } from '../../../shared/utils/server/jobs'
+} from '../../../shared/extra-utils'
+import { getJobsListPaginationAndSort } from '../../../shared/extra-utils/server/jobs'
 
 interface ServerInfo extends DefaultServerInfo {
   requestsNumber: number
diff --git a/server/tools/cli.ts b/server/tools/cli.ts
index 108c44218..59e9fcfc4 100644
--- a/server/tools/cli.ts
+++ b/server/tools/cli.ts
@@ -3,51 +3,83 @@ const netrc = require('netrc-parser').default
 
 const version = require('../../../package.json').version
 
-let settings = {
-  remotes: [],
-  default: 0
-}
-
 interface Settings {
   remotes: any[],
   default: number
 }
 
-async function getSettings () {
+function getSettings () {
   return new Promise<Settings>((res, rej) => {
-    let settings = {
+    const defaultSettings = {
       remotes: [],
       default: 0
-    } as Settings
+    }
+
     config.read((err, data) => {
-      if (err) {
-        return rej(err)
-      }
-      return res(Object.keys(data).length === 0 ? settings : data)
+      if (err) return rej(err)
+
+      return res(Object.keys(data).length === 0 ? defaultSettings : data)
     })
   })
 }
 
-async function writeSettings (settings) {
+async function getNetrc () {
+  await netrc.load()
+
+  return netrc
+}
+
+function writeSettings (settings) {
   return new Promise((res, rej) => {
     config.write(settings, function (err) {
-      if (err) {
-        return rej(err)
-      }
+      if (err) return rej(err)
+
       return res()
     })
   })
 }
 
-netrc.loadSync()
+function getRemoteObjectOrDie (program: any, settings: Settings) {
+  if (!program['url'] || !program['username'] || !program['password']) {
+    // No remote and we don't have program parameters: throw
+    if (settings.remotes.length === 0) {
+      if (!program[ 'url' ]) console.error('--url field is required.')
+      if (!program[ 'username' ]) console.error('--username field is required.')
+      if (!program[ 'password' ]) console.error('--password field is required.')
+
+      return process.exit(-1)
+    }
+
+    let url: string = program['url']
+    let username: string = program['username']
+    let password: string = program['password']
+
+    if (!url) {
+      url = settings.default !== -1
+        ? settings.remotes[settings.default]
+        : settings.remotes[0]
+    }
+
+    if (!username) username = netrc.machines[url].login
+    if (!password) password = netrc.machines[url].password
+
+    return { url, username, password }
+  }
+
+  return {
+    url: program[ 'url' ],
+    username: program[ 'username' ],
+    password: program[ 'password' ]
+  }
+}
 
 // ---------------------------------------------------------------------------
 
 export {
   version,
   config,
-  settings,
   getSettings,
-  writeSettings,
-  netrc
+  getNetrc,
+  getRemoteObjectOrDie,
+  writeSettings
 }
diff --git a/server/tools/peertube-auth.ts b/server/tools/peertube-auth.ts
index a962944a4..8bc3d332c 100644
--- a/server/tools/peertube-auth.ts
+++ b/server/tools/peertube-auth.ts
@@ -1,22 +1,25 @@
 import * as program from 'commander'
 import * as prompt from 'prompt'
-const Table = require('cli-table')
-import { getSettings, writeSettings, netrc } from './cli'
+import { getSettings, writeSettings, getNetrc } from './cli'
 import { isHostValid } from '../helpers/custom-validators/servers'
 import { isUserUsernameValid } from '../helpers/custom-validators/users'
 
+const Table = require('cli-table')
+
 async function delInstance (url: string) {
-  const settings = await getSettings()
+  const [ settings, netrc ] = await Promise.all([ getSettings(), getNetrc() ])
 
   settings.remotes.splice(settings.remotes.indexOf(url))
   await writeSettings(settings)
 
   delete netrc.machines[url]
+
   await netrc.save()
 }
 
 async function setInstance (url: string, username: string, password: string) {
-  const settings = await getSettings()
+  const [ settings, netrc ] = await Promise.all([ getSettings(), getNetrc() ])
+
   if (settings.remotes.indexOf(url) === -1) {
     settings.remotes.push(url)
   }
@@ -82,12 +85,13 @@ program
   .command('list')
   .description('lists registered remote instances')
   .action(async () => {
-    const settings = await getSettings()
+    const [ settings, netrc ] = await Promise.all([ getSettings(), getNetrc() ])
+
     const table = new Table({
       head: ['instance', 'login'],
       colWidths: [30, 30]
     })
-    netrc.loadSync()
+
     settings.remotes.forEach(element => {
       table.push([
         element,
diff --git a/server/tools/peertube-get-access-token.ts b/server/tools/peertube-get-access-token.ts
index a68665f5b..85660de2c 100644
--- a/server/tools/peertube-get-access-token.ts
+++ b/server/tools/peertube-get-access-token.ts
@@ -6,7 +6,7 @@ import {
   Server,
   Client,
   User
-} from '../../shared/utils'
+} from '../../shared/extra-utils'
 
 program
   .option('-u, --url <url>', 'Server url')
diff --git a/server/tools/peertube-import-videos.ts b/server/tools/peertube-import-videos.ts
index f50aafc35..9a366dbbd 100644
--- a/server/tools/peertube-import-videos.ts
+++ b/server/tools/peertube-import-videos.ts
@@ -5,14 +5,14 @@ import * as program from 'commander'
 import { join } from 'path'
 import { VideoPrivacy } from '../../shared/models/videos'
 import { doRequestAndSaveToFile } from '../helpers/requests'
-import { CONSTRAINTS_FIELDS } from '../initializers'
-import { getClient, getVideoCategories, login, searchVideoWithSort, uploadVideo } from '../../shared/utils/index'
+import { CONSTRAINTS_FIELDS } from '../initializers/constants'
+import { getClient, getVideoCategories, login, searchVideoWithSort, uploadVideo } from '../../shared/extra-utils/index'
 import { truncate } from 'lodash'
 import * as prompt from 'prompt'
 import { remove } from 'fs-extra'
 import { sha256 } from '../helpers/core-utils'
-import { safeGetYoutubeDL } from '../helpers/youtube-dl'
-import { getSettings, netrc } from './cli'
+import { buildOriginallyPublishedAt, safeGetYoutubeDL } from '../helpers/youtube-dl'
+import { getNetrc, getRemoteObjectOrDie, getSettings } from './cli'
 
 let accessToken: string
 let client: { id: string, secret: string }
@@ -32,58 +32,30 @@ program
   .option('-v, --verbose', 'Verbose mode')
   .parse(process.argv)
 
-getSettings()
-.then(settings => {
-  if (
-    (!program['url'] ||
-    !program['username'] ||
-    !program['password']) &&
-    (settings.remotes.length === 0)
-  ) {
-    if (!program['url']) console.error('--url field is required.')
-    if (!program['username']) console.error('--username field is required.')
-    if (!program['password']) console.error('--password field is required.')
-    if (!program['targetUrl']) console.error('--targetUrl field is required.')
-    process.exit(-1)
-  }
-
-  if (
-    (!program['url'] ||
-    !program['username'] ||
-    !program['password']) &&
-    (settings.remotes.length > 0)
-  ) {
-    if (!program['url']) {
-      program['url'] = (settings.default !== -1) ?
-        settings.remotes[settings.default] :
-        settings.remotes[0]
-    }
+Promise.all([ getSettings(), getNetrc() ])
+       .then(([ settings, netrc ]) => {
+         const { url, username, password } = getRemoteObjectOrDie(program, settings)
 
-    if (!program['username']) program['username'] = netrc.machines[program['url']].login
-    if (!program['password']) program['password'] = netrc.machines[program['url']].password
-  }
+         if (!program[ 'targetUrl' ]) {
+           console.error('--targetUrl field is required.')
 
-  if (
-    !program['targetUrl']
-  ) {
-    if (!program['targetUrl']) console.error('--targetUrl field is required.')
-    process.exit(-1)
-  }
+           process.exit(-1)
+         }
 
-  removeEndSlashes(program['url'])
-  removeEndSlashes(program['targetUrl'])
+         removeEndSlashes(url)
+         removeEndSlashes(program[ 'targetUrl' ])
 
-  const user = {
-    username: program['username'],
-    password: program['password']
-  }
+         const user = {
+           username: username,
+           password: password
+         }
 
-  run(user, program['url'])
-    .catch(err => {
-      console.error(err)
-      process.exit(-1)
-    })
-})
+         run(user, url)
+           .catch(err => {
+             console.error(err)
+             process.exit(-1)
+           })
+       })
 
 async function promptPassword () {
   return new Promise((res, rej) => {
@@ -126,7 +98,7 @@ async function run (user, url: string) {
   const youtubeDL = await safeGetYoutubeDL()
 
   const options = [ '-j', '--flat-playlist', '--playlist-reverse' ]
-  youtubeDL.getInfo(program['targetUrl'], options, processOptions, async (err, info) => {
+  youtubeDL.getInfo(program[ 'targetUrl' ], options, processOptions, async (err, info) => {
     if (err) {
       console.log(err.message)
       process.exit(1)
@@ -143,20 +115,20 @@ async function run (user, url: string) {
     console.log('Will download and upload %d videos.\n', infoArray.length)
 
     for (const info of infoArray) {
-      await processVideo(info, program['language'], processOptions.cwd, url, user)
+      await processVideo(info, program[ 'language' ], processOptions.cwd, url, user)
     }
 
-    console.log('Video/s for user %s imported: %s', program['username'], program['targetUrl'])
+    console.log('Video/s for user %s imported: %s', program[ 'username' ], program[ 'targetUrl' ])
     process.exit(0)
   })
 }
 
 function processVideo (info: any, languageCode: string, cwd: string, url: string, user) {
   return new Promise(async res => {
-    if (program['verbose']) console.log('Fetching object.', info)
+    if (program[ 'verbose' ]) console.log('Fetching object.', info)
 
     const videoInfo = await fetchObject(info)
-    if (program['verbose']) console.log('Fetched object.', videoInfo)
+    if (program[ 'verbose' ]) console.log('Fetched object.', videoInfo)
 
     const result = await searchVideoWithSort(url, videoInfo.title, '-match')
 
@@ -197,9 +169,9 @@ async function uploadVideoOnPeerTube (videoInfo: any, videoPath: string, cwd: st
   let tags = []
   if (Array.isArray(videoInfo.tags)) {
     tags = videoInfo.tags
-      .filter(t => t.length < CONSTRAINTS_FIELDS.VIDEOS.TAG.max && t.length > CONSTRAINTS_FIELDS.VIDEOS.TAG.min)
-      .map(t => t.normalize())
-      .slice(0, 5)
+                    .filter(t => t.length < CONSTRAINTS_FIELDS.VIDEOS.TAG.max && t.length > CONSTRAINTS_FIELDS.VIDEOS.TAG.min)
+                    .map(t => t.normalize())
+                    .slice(0, 5)
   }
 
   let thumbnailfile
@@ -212,6 +184,8 @@ async function uploadVideoOnPeerTube (videoInfo: any, videoPath: string, cwd: st
     }, thumbnailfile)
   }
 
+  const originallyPublishedAt = buildOriginallyPublishedAt(videoInfo)
+
   const videoAttributes = {
     name: truncate(videoInfo.title, {
       'length': CONSTRAINTS_FIELDS.VIDEOS.NAME.max,
@@ -224,13 +198,15 @@ async function uploadVideoOnPeerTube (videoInfo: any, videoPath: string, cwd: st
     nsfw: isNSFW(videoInfo),
     waitTranscoding: true,
     commentsEnabled: true,
+    downloadEnabled: true,
     description: videoInfo.description || undefined,
     support: undefined,
     tags,
     privacy: VideoPrivacy.PUBLIC,
     fixture: videoPath,
     thumbnailfile,
-    previewfile: thumbnailfile
+    previewfile: thumbnailfile,
+    originallyPublishedAt: originallyPublishedAt ? originallyPublishedAt.toISOString() : null
   }
 
   console.log('\nUploading on PeerTube video "%s".', videoAttributes.name)
@@ -259,7 +235,7 @@ async function uploadVideoOnPeerTube (videoInfo: any, videoPath: string, cwd: st
 async function getCategory (categories: string[], url: string) {
   if (!categories) return undefined
 
-  const categoryString = categories[0]
+  const categoryString = categories[ 0 ]
 
   if (categoryString === 'News & Politics') return 11
 
@@ -267,7 +243,7 @@ async function getCategory (categories: string[], url: string) {
   const categoriesServer = res.body
 
   for (const key of Object.keys(categoriesServer)) {
-    const categoryServer = categoriesServer[key]
+    const categoryServer = categoriesServer[ key ]
     if (categoryString.toLowerCase() === categoryServer.toLowerCase()) return parseInt(key, 10)
   }
 
@@ -291,12 +267,12 @@ function normalizeObject (obj: any) {
     // Deprecated key
     if (key === 'resolution') continue
 
-    const value = obj[key]
+    const value = obj[ key ]
 
     if (typeof value === 'string') {
-      newObj[key] = value.normalize()
+      newObj[ key ] = value.normalize()
     } else {
-      newObj[key] = value
+      newObj[ key ] = value
     }
   }
 
diff --git a/server/tools/peertube-upload.ts b/server/tools/peertube-upload.ts
index cc7bd9b4c..687f2e60b 100644
--- a/server/tools/peertube-upload.ts
+++ b/server/tools/peertube-upload.ts
@@ -1,10 +1,10 @@
 import * as program from 'commander'
 import { access, constants } from 'fs-extra'
 import { isAbsolute } from 'path'
-import { getClient, login } from '../../shared/utils'
-import { uploadVideo } from '../../shared/utils/'
+import { getClient, login } from '../../shared/extra-utils'
+import { uploadVideo } from '../../shared/extra-utils/'
 import { VideoPrivacy } from '../../shared/models/videos'
-import { netrc, getSettings } from './cli'
+import { getRemoteObjectOrDie, getSettings } from './cli'
 
 program
   .name('upload')
@@ -26,48 +26,15 @@ program
   .option('-f, --file <file>', 'Video absolute file path')
   .parse(process.argv)
 
-if (!program['tags']) program['tags'] = []
-if (!program['nsfw']) program['nsfw'] = false
-if (!program['privacy']) program['privacy'] = VideoPrivacy.PUBLIC
-if (!program['commentsEnabled']) program['commentsEnabled'] = false
-
 getSettings()
   .then(settings => {
-    if (
-      (!program['url'] ||
-      !program['username'] ||
-      !program['password']) &&
-      (settings.remotes.length === 0)
-    ) {
-      if (!program['url']) console.error('--url field is required.')
-      if (!program['username']) console.error('--username field is required.')
-      if (!program['password']) console.error('--password field is required.')
-      if (!program['videoName']) console.error('--video-name field is required.')
-      if (!program['file']) console.error('--file field is required.')
-      process.exit(-1)
-    }
+    const { url, username, password } = getRemoteObjectOrDie(program, settings)
 
-    if (
-      (!program['url'] ||
-      !program['username'] ||
-      !program['password']) &&
-      (settings.remotes.length > 0)
-    ) {
-      if (!program['url']) {
-        program['url'] = (settings.default !== -1) ?
-          settings.remotes[settings.default] :
-          settings.remotes[0]
-      }
-      if (!program['username']) program['username'] = netrc.machines[program['url']].login
-      if (!program['password']) program['password'] = netrc.machines[program['url']].password
-    }
+    if (!program['videoName'] || !program['file'] || !program['channelId']) {
+      if (!program['videoName']) console.error('--video-name is required.')
+      if (!program['file']) console.error('--file is required.')
+      if (!program['channelId']) console.error('--channel-id is required.')
 
-    if (
-      !program['videoName'] ||
-      !program['file']
-    ) {
-      if (!program['videoName']) console.error('--video-name field is required.')
-      if (!program['file']) console.error('--file field is required.')
       process.exit(-1)
     }
 
@@ -76,28 +43,25 @@ getSettings()
       process.exit(-1)
     }
 
-    run().catch(err => {
+    run(url, username, password).catch(err => {
       console.error(err)
       process.exit(-1)
     })
   })
 
-async function run () {
-  const res = await getClient(program[ 'url' ])
+async function run (url: string, username: string, password: string) {
+  const resClient = await getClient(program[ 'url' ])
   const client = {
-    id: res.body.client_id,
-    secret: res.body.client_secret
+    id: resClient.body.client_id,
+    secret: resClient.body.client_secret
   }
 
-  const user = {
-    username: program[ 'username' ],
-    password: program[ 'password' ]
-  }
+  const user = { username, password }
 
   let accessToken: string
   try {
-    const res2 = await login(program[ 'url' ], client, user)
-    accessToken = res2.body.access_token
+    const res = await login(url, client, user)
+    accessToken = res.body.access_token
   } catch (err) {
     throw new Error('Cannot authenticate. Please check your username/password.')
   }
@@ -108,26 +72,32 @@ async function run () {
 
   const videoAttributes = {
     name: program['videoName'],
-    category: program['category'],
+    category: program['category'] || undefined,
     channelId: program['channelId'],
-    licence: program['licence'],
-    language: program['language'],
-    nsfw: program['nsfw'],
-    description: program['videoDescription'],
-    tags: program['tags'],
-    commentsEnabled: program['commentsEnabled'],
+    licence: program['licence'] || undefined,
+    language: program['language'] || undefined,
+    nsfw: program['nsfw'] !== undefined ? program['nsfw'] : false,
+    description: program['videoDescription'] || '',
+    tags: program['tags'] || [],
+    commentsEnabled: program['commentsEnabled'] !== undefined ? program['commentsEnabled'] : true,
+    downloadEnabled: program['downloadEnabled'] !== undefined ? program['downloadEnabled'] : true,
     fixture: program['file'],
     thumbnailfile: program['thumbnail'],
     previewfile: program['preview'],
     waitTranscoding: true,
-    privacy: program['privacy'],
+    privacy: program['privacy'] || VideoPrivacy.PUBLIC,
     support: undefined
   }
 
-  await uploadVideo(program[ 'url' ], accessToken, videoAttributes)
-
-  console.log(`Video ${program['videoName']} uploaded.`)
-  process.exit(0)
+  try {
+    await uploadVideo(url, accessToken, videoAttributes)
+    console.log(`Video ${program['videoName']} uploaded.`)
+    process.exit(0)
+  } catch (err) {
+    console.log('coucou')
+    console.error(require('util').inspect(err))
+    process.exit(-1)
+  }
 }
 
 // ----------------------------------------------------------------------------
diff --git a/server/typings/express.ts b/server/typings/express.ts
new file mode 100644
index 000000000..324d78662
--- /dev/null
+++ b/server/typings/express.ts
@@ -0,0 +1,82 @@
+import { VideoChannelModel } from '../models/video/video-channel'
+import { VideoPlaylistModel } from '../models/video/video-playlist'
+import { VideoPlaylistElementModel } from '../models/video/video-playlist-element'
+import { UserModel } from '../models/account/user'
+import { VideoModel } from '../models/video/video'
+import { AccountModel } from '../models/account/account'
+import { VideoChangeOwnershipModel } from '../models/video/video-change-ownership'
+import { ActorModel } from '../models/activitypub/actor'
+import { VideoCommentModel } from '../models/video/video-comment'
+import { VideoShareModel } from '../models/video/video-share'
+import { AccountVideoRateModel } from '../models/account/account-video-rate'
+import { ActorFollowModel } from '../models/activitypub/actor-follow'
+import { ServerModel } from '../models/server/server'
+import { VideoFileModel } from '../models/video/video-file'
+import { VideoRedundancyModel } from '../models/redundancy/video-redundancy'
+import { ServerBlocklistModel } from '../models/server/server-blocklist'
+import { AccountBlocklistModel } from '../models/account/account-blocklist'
+import { VideoImportModel } from '../models/video/video-import'
+import { VideoAbuseModel } from '../models/video/video-abuse'
+import { VideoBlacklistModel } from '../models/video/video-blacklist'
+import { VideoCaptionModel } from '../models/video/video-caption'
+import { VideoStreamingPlaylistModel } from '../models/video/video-streaming-playlist'
+
+declare module 'express' {
+
+  interface Response {
+    locals: {
+      video?: VideoModel
+      videoShare?: VideoShareModel
+      videoFile?: VideoFileModel
+
+      videoImport?: VideoImportModel
+
+      videoBlacklist?: VideoBlacklistModel
+
+      videoCaption?: VideoCaptionModel
+
+      videoAbuse?: VideoAbuseModel
+
+      videoStreamingPlaylist?: VideoStreamingPlaylistModel
+
+      videoChannel?: VideoChannelModel
+
+      videoPlaylist?: VideoPlaylistModel
+      videoPlaylistElement?: VideoPlaylistElementModel
+
+      accountVideoRate?: AccountVideoRateModel
+
+      videoComment?: VideoCommentModel
+      videoCommentThread?: VideoCommentModel
+
+      follow?: ActorFollowModel
+      subscription?: ActorFollowModel
+
+      nextOwner?: AccountModel
+      videoChangeOwnership?: VideoChangeOwnershipModel
+      account?: AccountModel
+      actor?: ActorModel
+      user?: UserModel
+
+      server?: ServerModel
+
+      videoRedundancy?: VideoRedundancyModel
+
+      accountBlock?: AccountBlocklistModel
+      serverBlock?: ServerBlocklistModel
+
+      oauth?: {
+        token: {
+          User: UserModel
+          user: UserModel
+        }
+      }
+
+      signature?: {
+        actor: ActorModel
+      }
+
+      authenticated?: boolean
+    }
+  }
+}
diff --git a/server/typings/sequelize.ts b/server/typings/sequelize.ts
new file mode 100644
index 000000000..9cd83612d
--- /dev/null
+++ b/server/typings/sequelize.ts
@@ -0,0 +1,18 @@
+import { Model } from 'sequelize-typescript'
+
+// Thanks to sequelize-typescript: https://github.com/RobinBuschmann/sequelize-typescript
+
+export type Diff<T extends string | symbol | number, U extends string | symbol | number> =
+  ({ [P in T]: P } & { [P in U]: never } & { [ x: string ]: never })[T]
+
+export type Omit<T, K extends keyof T> = { [P in Diff<keyof T, K>]: T[P] }
+
+export type RecursivePartial<T> = { [P in keyof T]?: RecursivePartial<T[P]> }
+
+export type FilteredModelAttributes<T extends Model<T>> = RecursivePartial<Omit<T, keyof Model<any>>> & {
+  id?: number | any
+  createdAt?: Date | any
+  updatedAt?: Date | any
+  deletedAt?: Date | any
+  version?: number | any
+}