109 files changed, 4120 insertions, 3150 deletions
diff --git a/server/lib/activitypub/actor.ts b/server/lib/activitypub/actor.ts
deleted file mode 100644
index 5fe7381c9..000000000
--- a/server/lib/activitypub/actor.ts
+++ /dev/null
@@ -1,594 +0,0 @@
-import * as Bluebird from 'bluebird'
-import { extname } from 'path'
-import { Op, Transaction } from 'sequelize'
-import { URL } from 'url'
-import { v4 as uuidv4 } from 'uuid'
-import { getServerActor } from '@server/models/application/application'
-import { ActorImageType } from '@shared/models'
-import { HttpStatusCode } from '../../../shared/core-utils/miscs/http-error-codes'
-import { ActivityPubActor, ActivityPubActorType, ActivityPubOrderedCollection } from '../../../shared/models/activitypub'
-import { ActivityPubAttributedTo } from '../../../shared/models/activitypub/objects'
-import { checkUrlsSameHost, getAPId } from '../../helpers/activitypub'
-import { ActorFetchByUrlType, fetchActorByUrl } from '../../helpers/actor'
-import { sanitizeAndCheckActorObject } from '../../helpers/custom-validators/activitypub/actor'
-import { isActivityPubUrlValid } from '../../helpers/custom-validators/activitypub/misc'
-import { retryTransactionWrapper, updateInstanceWithAnother } from '../../helpers/database-utils'
-import { logger } from '../../helpers/logger'
-import { createPrivateAndPublicKeys } from '../../helpers/peertube-crypto'
-import { doJSONRequest, PeerTubeRequestError } from '../../helpers/requests'
-import { getUrlFromWebfinger } from '../../helpers/webfinger'
-import { MIMETYPES, WEBSERVER } from '../../initializers/constants'
-import { sequelizeTypescript } from '../../initializers/database'
-import { AccountModel } from '../../models/account/account'
-import { ActorImageModel } from '../../models/account/actor-image'
-import { ActorModel } from '../../models/activitypub/actor'
-import { ServerModel } from '../../models/server/server'
-import { VideoChannelModel } from '../../models/video/video-channel'
-import {
-  MAccount,
-  MAccountDefault,
-  MActor,
-  MActorAccountChannelId,
-  MActorAccountChannelIdActor,
-  MActorAccountId,
-  MActorFull,
-  MActorFullActor,
-  MActorId,
-  MActorImage,
-  MActorImages,
-  MChannel
-} from '../../types/models'
-import { JobQueue } from '../job-queue'
-// Set account keys, this could be long so process after the account creation and do not block the client
-async function generateAndSaveActorKeys <T extends MActor> (actor: T) {
-  const { publicKey, privateKey } = await createPrivateAndPublicKeys()
-  actor.publicKey = publicKey
-  actor.privateKey = privateKey
-  return actor.save()
-}
-function getOrCreateActorAndServerAndModel (
-  activityActor: string | ActivityPubActor,
-  fetchType: 'all',
-  recurseIfNeeded?: boolean,
-  updateCollections?: boolean
-): Promise<MActorFullActor>
-function getOrCreateActorAndServerAndModel (
-  activityActor: string | ActivityPubActor,
-  fetchType?: 'association-ids',
-  recurseIfNeeded?: boolean,
-  updateCollections?: boolean
-): Promise<MActorAccountChannelId>
-async function getOrCreateActorAndServerAndModel (
-  activityActor: string | ActivityPubActor,
-  fetchType: ActorFetchByUrlType = 'association-ids',
-  recurseIfNeeded = true,
-  updateCollections = false
-): Promise<MActorFullActor | MActorAccountChannelId> {
-  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
-  if (actor && (!actor.Account && !actor.VideoChannel)) {
-    await actor.destroy()
-    actor = null
-  }
-  // We don't have this actor in our database, fetch it on remote
-  if (!actor) {
-    const { result } = await fetchRemoteActor(actorUrl)
-    if (result === undefined) throw new Error('Cannot fetch remote actor ' + actorUrl)
-    // Create the attributed to actor
-    // In PeerTube a video channel is owned by an account
-    let ownerActor: MActorFullActor
-    if (recurseIfNeeded === true && result.actor.type === 'Group') {
-      const accountAttributedTo = result.attributedTo.find(a => a.type === 'Person')
-      if (!accountAttributedTo) throw new Error('Cannot find account attributed to video channel ' + actor.url)
-      if (checkUrlsSameHost(accountAttributedTo.id, actorUrl) !== true) {
-        throw new Error(`Account attributed to ${accountAttributedTo.id} does not have the same host than actor url ${actorUrl}`)
-      }
-      try {
-        // Don't recurse another time
-        const recurseIfNeeded = false
-        ownerActor = await getOrCreateActorAndServerAndModel(accountAttributedTo.id, 'all', recurseIfNeeded)
-      } catch (err) {
-        logger.error('Cannot get or create account attributed to video channel ' + actorUrl)
-        throw new Error(err)
-      }
-    }
-    actor = await retryTransactionWrapper(saveActorAndServerAndModelIfNotExist, result, ownerActor)
-    created = true
-    accountPlaylistsUrl = result.playlists
-  }
-  if (actor.Account) (actor as MActorAccountChannelIdActor).Account.Actor = actor
-  if (actor.VideoChannel) (actor as MActorAccountChannelIdActor).VideoChannel.Actor = actor
-  const { actor: actorRefreshed, refreshed } = await retryTransactionWrapper(refreshActorIfNeeded, actor, fetchType)
-  if (!actorRefreshed) throw new Error('Actor ' + actor.url + ' does not exist anymore.')
-  if ((created === true || refreshed === true) && updateCollections === true) {
-    const payload = { uri: actor.outboxUrl, type: 'activity' as 'activity' }
-    await JobQueue.Instance.createJobWithPromise({ 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.createJobWithPromise({ type: 'activitypub-http-fetcher', payload })
-  }
-  return actorRefreshed
-}
-function buildActorInstance (type: ActivityPubActorType, url: string, preferredUsername: string, uuid?: string) {
-  return new ActorModel({
-    type,
-    url,
-    preferredUsername,
-    uuid,
-    publicKey: null,
-    privateKey: null,
-    followersCount: 0,
-    followingCount: 0,
-    inboxUrl: url + '/inbox',
-    outboxUrl: url + '/outbox',
-    sharedInboxUrl: WEBSERVER.URL + '/inbox',
-    followersUrl: url + '/followers',
-    followingUrl: url + '/following'
-  }) as MActor
-}
-async function updateActorInstance (actorInstance: ActorModel, attributes: ActivityPubActor) {
-  const followersCount = await fetchActorTotalItems(attributes.followers)
-  const followingCount = await fetchActorTotalItems(attributes.following)
-  actorInstance.type = attributes.type
-  actorInstance.preferredUsername = attributes.preferredUsername
-  actorInstance.url = attributes.id
-  actorInstance.publicKey = attributes.publicKey.publicKeyPem
-  actorInstance.followersCount = followersCount
-  actorInstance.followingCount = followingCount
-  actorInstance.inboxUrl = attributes.inbox
-  actorInstance.outboxUrl = attributes.outbox
-  actorInstance.followersUrl = attributes.followers
-  actorInstance.followingUrl = attributes.following
-  if (attributes.published) actorInstance.remoteCreatedAt = new Date(attributes.published)
-  if (attributes.endpoints?.sharedInbox) {
-    actorInstance.sharedInboxUrl = attributes.endpoints.sharedInbox
-  }
-}
-type ImageInfo = {
-  name: string
-  fileUrl: string
-  height: number
-  width: number
-  onDisk?: boolean
-}
-async function updateActorImageInstance (actor: MActorImages, type: ActorImageType, imageInfo: ImageInfo | null, t: Transaction) {
-  const oldImageModel = type === ActorImageType.AVATAR
-    ? actor.Avatar
-    : actor.Banner
-  if (oldImageModel) {
-    // Don't update the avatar if the file URL did not change
-    if (imageInfo?.fileUrl && oldImageModel.fileUrl === imageInfo.fileUrl) return actor
-    try {
-      await oldImageModel.destroy({ transaction: t })
-      setActorImage(actor, type, null)
-    } catch (err) {
-      logger.error('Cannot remove old actor image of actor %s.', actor.url, { err })
-    }
-  }
-  if (imageInfo) {
-    const imageModel = await ActorImageModel.create({
-      filename: imageInfo.name,
-      onDisk: imageInfo.onDisk ?? false,
-      fileUrl: imageInfo.fileUrl,
-      height: imageInfo.height,
-      width: imageInfo.width,
-      type
-    }, { transaction: t })
-    setActorImage(actor, type, imageModel)
-  }
-  return actor
-}
-async function deleteActorImageInstance (actor: MActorImages, type: ActorImageType, t: Transaction) {
-  try {
-    if (type === ActorImageType.AVATAR) {
-      await actor.Avatar.destroy({ transaction: t })
-      actor.avatarId = null
-      actor.Avatar = null
-    } else {
-      await actor.Banner.destroy({ transaction: t })
-      actor.bannerId = null
-      actor.Banner = null
-    }
-  } catch (err) {
-    logger.error('Cannot remove old image of actor %s.', actor.url, { err })
-  }
-  return actor
-}
-async function fetchActorTotalItems (url: string) {
-  try {
-    const { body } = await doJSONRequest<ActivityPubOrderedCollection<unknown>>(url, { activityPub: true })
-    return body.totalItems || 0
-  } catch (err) {
-    logger.warn('Cannot fetch remote actor count %s.', url, { err })
-    return 0
-  }
-}
-function getImageInfoIfExists (actorJSON: ActivityPubActor, type: ActorImageType) {
-  const mimetypes = MIMETYPES.IMAGE
-  const icon = type === ActorImageType.AVATAR
-    ? actorJSON.icon
-    : actorJSON.image
-  if (!icon || icon.type !== 'Image' || !isActivityPubUrlValid(icon.url)) return undefined
-  let extension: string
-  if (icon.mediaType) {
-    extension = mimetypes.MIMETYPE_EXT[icon.mediaType]
-  } else {
-    const tmp = extname(icon.url)
-    if (mimetypes.EXT_MIMETYPE[tmp] !== undefined) extension = tmp
-  }
-  if (!extension) return undefined
-  return {
-    name: uuidv4() + extension,
-    fileUrl: icon.url,
-    height: icon.height,
-    width: icon.width,
-    type
-  }
-}
-async function addFetchOutboxJob (actor: Pick<ActorModel, 'id' | 'outboxUrl'>) {
-  // Don't fetch ourselves
-  const serverActor = await getServerActor()
-  if (serverActor.id === actor.id) {
-    logger.error('Cannot fetch our own outbox!')
-    return undefined
-  }
-  const payload = {
-    uri: actor.outboxUrl,
-    type: 'activity' as 'activity'
-  }
-  return JobQueue.Instance.createJob({ type: 'activitypub-http-fetcher', payload })
-}
-async function refreshActorIfNeeded <T extends MActorFull | MActorAccountChannelId> (
-  actorArg: T,
-  fetchedType: ActorFetchByUrlType
-): Promise<{ actor: T | MActorFull, refreshed: boolean }> {
-  if (!actorArg.isOutdated()) return { actor: actorArg, refreshed: false }
-  // We need more attributes
-  const actor = fetchedType === 'all'
-    ? actorArg as MActorFull
-    : await ActorModel.loadByUrlAndPopulateAccountAndChannel(actorArg.url)
-  try {
-    let actorUrl: string
-    try {
-      actorUrl = await getUrlFromWebfinger(actor.preferredUsername + '@' + actor.getHost())
-    } catch (err) {
-      logger.warn('Cannot get actor URL from webfinger, keeping the old one.', err)
-      actorUrl = actor.url
-    }
-    const { result } = await fetchRemoteActor(actorUrl)
-    if (result === undefined) {
-      logger.warn('Cannot fetch remote actor in refresh actor.')
-      return { actor, refreshed: false }
-    }
-    return sequelizeTypescript.transaction(async t => {
-      updateInstanceWithAnother(actor, result.actor)
-      await updateActorImageInstance(actor, ActorImageType.AVATAR, result.avatar, t)
-      await updateActorImageInstance(actor, ActorImageType.BANNER, result.banner, t)
-      // Force update
-      actor.setDataValue('updatedAt', new Date())
-      await actor.save({ transaction: t })
-      if (actor.Account) {
-        actor.Account.name = result.name
-        actor.Account.description = result.summary
-        await actor.Account.save({ transaction: t })
-      } else if (actor.VideoChannel) {
-        actor.VideoChannel.name = result.name
-        actor.VideoChannel.description = result.summary
-        actor.VideoChannel.support = result.support
-        await actor.VideoChannel.save({ transaction: t })
-      }
-      return { refreshed: true, actor }
-    })
-  } catch (err) {
-    if ((err as PeerTubeRequestError).statusCode === HttpStatusCode.NOT_FOUND_404) {
-      logger.info('Deleting actor %s because there is a 404 in refresh actor.', actor.url)
-      actor.Account
-        ? await actor.Account.destroy()
-        : await actor.VideoChannel.destroy()
-      return { actor: undefined, refreshed: false }
-    }
-    logger.warn('Cannot refresh actor %s.', actor.url, { err })
-    return { actor, refreshed: false }
-  }
-}
-export {
-  getOrCreateActorAndServerAndModel,
-  buildActorInstance,
-  generateAndSaveActorKeys,
-  fetchActorTotalItems,
-  getImageInfoIfExists,
-  updateActorInstance,
-  deleteActorImageInstance,
-  refreshActorIfNeeded,
-  updateActorImageInstance,
-  addFetchOutboxJob
-}
-// ---------------------------------------------------------------------------
-function setActorImage (actorModel: MActorImages, type: ActorImageType, imageModel: MActorImage) {
-  const id = imageModel
-    ? imageModel.id
-    : null
-  if (type === ActorImageType.AVATAR) {
-    actorModel.avatarId = id
-    actorModel.Avatar = imageModel
-  } else {
-    actorModel.bannerId = id
-    actorModel.Banner = imageModel
-  }
-  return actorModel
-}
-function saveActorAndServerAndModelIfNotExist (
-  result: FetchRemoteActorResult,
-  ownerActor?: MActorFullActor,
-  t?: Transaction
-): Bluebird<MActorFullActor> | Promise<MActorFullActor> {
-  const actor = result.actor
-  if (t !== undefined) return save(t)
-  return sequelizeTypescript.transaction(t => save(t))
-  async function save (t: Transaction) {
-    const actorHost = new URL(actor.url).host
-    const serverOptions = {
-      where: {
-        host: actorHost
-      },
-      defaults: {
-        host: actorHost
-      },
-      transaction: t
-    }
-    const [ server ] = await ServerModel.findOrCreate(serverOptions)
-    // Save our new account in database
-    actor.serverId = server.id
-    // Avatar?
-    if (result.avatar) {
-      const avatar = await ActorImageModel.create({
-        filename: result.avatar.name,
-        fileUrl: result.avatar.fileUrl,
-        width: result.avatar.width,
-        height: result.avatar.height,
-        onDisk: false,
-        type: ActorImageType.AVATAR
-      }, { transaction: t })
-      actor.avatarId = avatar.id
-    }
-    // Banner?
-    if (result.banner) {
-      const banner = await ActorImageModel.create({
-        filename: result.banner.name,
-        fileUrl: result.banner.fileUrl,
-        width: result.banner.width,
-        height: result.banner.height,
-        onDisk: false,
-        type: ActorImageType.BANNER
-      }, { transaction: t })
-      actor.bannerId = banner.id
-    }
-    // Force the actor creation, sometimes Sequelize skips the save() when it thinks the instance already exists
-    // (which could be false in a retried query)
-    const [ actorCreated, created ] = await ActorModel.findOrCreate<MActorFullActor>({
-      defaults: actor.toJSON(),
-      where: {
-        [Op.or]: [
-          {
-            url: actor.url
-          },
-          {
-            serverId: actor.serverId,
-            preferredUsername: actor.preferredUsername
-          }
-        ]
-      },
-      transaction: t
-    })
-    // Try to fix non HTTPS accounts of remote instances that fixed their URL afterwards
-    if (created !== true && actorCreated.url !== actor.url) {
-      // Only fix http://example.com/account/djidane to https://example.com/account/djidane
-      if (actorCreated.url.replace(/^http:\/\//, '') !== actor.url.replace(/^https:\/\//, '')) {
-        throw new Error(`Actor from DB with URL ${actorCreated.url} does not correspond to actor ${actor.url}`)
-      }
-      actorCreated.url = actor.url
-      await actorCreated.save({ transaction: t })
-    }
-    if (actorCreated.type === 'Person' || actorCreated.type === 'Application') {
-      actorCreated.Account = await saveAccount(actorCreated, result, t) as MAccountDefault
-      actorCreated.Account.Actor = actorCreated
-    } else if (actorCreated.type === 'Group') { // Video channel
-      const channel = await saveVideoChannel(actorCreated, result, ownerActor, t)
-      actorCreated.VideoChannel = Object.assign(channel, { Actor: actorCreated, Account: ownerActor.Account })
-    }
-    actorCreated.Server = server
-    return actorCreated
-  }
-}
-type ImageResult = {
-  name: string
-  fileUrl: string
-  height: number
-  width: number
-}
-type FetchRemoteActorResult = {
-  actor: MActor
-  name: string
-  summary: string
-  support?: string
-  playlists?: string
-  avatar?: ImageResult
-  banner?: ImageResult
-  attributedTo: ActivityPubAttributedTo[]
-}
-async function fetchRemoteActor (actorUrl: string): Promise<{ statusCode?: number, result: FetchRemoteActorResult }> {
-  logger.info('Fetching remote actor %s.', actorUrl)
-  const requestResult = await doJSONRequest<ActivityPubActor>(actorUrl, { activityPub: true })
-  const actorJSON = requestResult.body
-  if (sanitizeAndCheckActorObject(actorJSON) === false) {
-    logger.debug('Remote actor JSON is not valid.', { actorJSON })
-    return { result: undefined, statusCode: requestResult.statusCode }
-  }
-  if (checkUrlsSameHost(actorJSON.id, actorUrl) !== true) {
-    logger.warn('Actor url %s has not the same host than its AP id %s', actorUrl, actorJSON.id)
-    return { result: undefined, statusCode: requestResult.statusCode }
-  }
-  const followersCount = await fetchActorTotalItems(actorJSON.followers)
-  const followingCount = await fetchActorTotalItems(actorJSON.following)
-  const actor = new ActorModel({
-    type: actorJSON.type,
-    preferredUsername: actorJSON.preferredUsername,
-    url: actorJSON.id,
-    publicKey: actorJSON.publicKey.publicKeyPem,
-    privateKey: null,
-    followersCount: followersCount,
-    followingCount: followingCount,
-    inboxUrl: actorJSON.inbox,
-    outboxUrl: actorJSON.outbox,
-    followersUrl: actorJSON.followers,
-    followingUrl: actorJSON.following,
-    sharedInboxUrl: actorJSON.endpoints?.sharedInbox
-      ? actorJSON.endpoints.sharedInbox
-      : null
-  })
-  const avatarInfo = getImageInfoIfExists(actorJSON, ActorImageType.AVATAR)
-  const bannerInfo = getImageInfoIfExists(actorJSON, ActorImageType.BANNER)
-  const name = actorJSON.name || actorJSON.preferredUsername
-  return {
-    statusCode: requestResult.statusCode,
-    result: {
-      actor,
-      name,
-      avatar: avatarInfo,
-      banner: bannerInfo,
-      summary: actorJSON.summary,
-      support: actorJSON.support,
-      playlists: actorJSON.playlists,
-      attributedTo: actorJSON.attributedTo
-    }
-  }
-}
-async function saveAccount (actor: MActorId, result: FetchRemoteActorResult, t: Transaction) {
-  const [ accountCreated ] = await AccountModel.findOrCreate({
-    defaults: {
-      name: result.name,
-      description: result.summary,
-      actorId: actor.id
-    },
-    where: {
-      actorId: actor.id
-    },
-    transaction: t
-  })
-  return accountCreated as MAccount
-}
-async function saveVideoChannel (actor: MActorId, result: FetchRemoteActorResult, ownerActor: MActorAccountId, t: Transaction) {
-  const [ videoChannelCreated ] = await VideoChannelModel.findOrCreate({
-    defaults: {
-      name: result.name,
-      description: result.summary,
-      support: result.support,
-      actorId: actor.id,
-      accountId: ownerActor.Account.id
-    },
-    where: {
-      actorId: actor.id
-    },
-    transaction: t
-  })
-  return videoChannelCreated as MChannel
-}
diff --git a/server/lib/activitypub/actors/get.ts b/server/lib/activitypub/actors/get.ts
new file mode 100644
index 000000000..8681ea02a
--- /dev/null
+++ b/server/lib/activitypub/actors/get.ts
@@ -0,0 +1,122 @@
+import { checkUrlsSameHost, getAPId } from '@server/helpers/activitypub'
+import { retryTransactionWrapper } from '@server/helpers/database-utils'
+import { logger } from '@server/helpers/logger'
+import { JobQueue } from '@server/lib/job-queue'
+import { ActorLoadByUrlType, loadActorByUrl } from '@server/lib/model-loaders'
+import { MActor, MActorAccountChannelId, MActorAccountChannelIdActor, MActorAccountId, MActorFullActor } from '@server/types/models'
+import { ActivityPubActor } from '@shared/models'
+import { refreshActorIfNeeded } from './refresh'
+import { APActorCreator, fetchRemoteActor } from './shared'
+function getOrCreateAPActor (
+  activityActor: string | ActivityPubActor,
+  fetchType: 'all',
+  recurseIfNeeded?: boolean,
+  updateCollections?: boolean
+): Promise<MActorFullActor>
+function getOrCreateAPActor (
+  activityActor: string | ActivityPubActor,
+  fetchType?: 'association-ids',
+  recurseIfNeeded?: boolean,
+  updateCollections?: boolean
+): Promise<MActorAccountChannelId>
+async function getOrCreateAPActor (
+  activityActor: string | ActivityPubActor,
+  fetchType: ActorLoadByUrlType = 'association-ids',
+  recurseIfNeeded = true,
+  updateCollections = false
+): Promise<MActorFullActor | MActorAccountChannelId> {
+  const actorUrl = getAPId(activityActor)
+  let actor = await loadActorFromDB(actorUrl, fetchType)
+  let created = false
+  let accountPlaylistsUrl: string
+  // We don't have this actor in our database, fetch it on remote
+  if (!actor) {
+    const { actorObject } = await fetchRemoteActor(actorUrl)
+    if (actorObject === undefined) throw new Error('Cannot fetch remote actor ' + actorUrl)
+    // actorUrl is just an alias/rediraction, so process object id instead
+    if (actorObject.id !== actorUrl) return getOrCreateAPActor(actorObject, 'all', recurseIfNeeded, updateCollections)
+    // Create the attributed to actor
+    // In PeerTube a video channel is owned by an account
+    let ownerActor: MActorFullActor
+    if (recurseIfNeeded === true && actorObject.type === 'Group') {
+      ownerActor = await getOrCreateAPOwner(actorObject, actorUrl)
+    }
+    const creator = new APActorCreator(actorObject, ownerActor)
+    actor = await retryTransactionWrapper(creator.create.bind(creator))
+    created = true
+    accountPlaylistsUrl = actorObject.playlists
+  }
+  if (actor.Account) (actor as MActorAccountChannelIdActor).Account.Actor = actor
+  if (actor.VideoChannel) (actor as MActorAccountChannelIdActor).VideoChannel.Actor = actor
+  const { actor: actorRefreshed, refreshed } = await refreshActorIfNeeded({ actor, fetchedType: fetchType })
+  if (!actorRefreshed) throw new Error('Actor ' + actor.url + ' does not exist anymore.')
+  await scheduleOutboxFetchIfNeeded(actor, created, refreshed, updateCollections)
+  await schedulePlaylistFetchIfNeeded(actor, created, accountPlaylistsUrl)
+  return actorRefreshed
+}
+// ---------------------------------------------------------------------------
+export {
+  getOrCreateAPActor
+}
+// ---------------------------------------------------------------------------
+async function loadActorFromDB (actorUrl: string, fetchType: ActorLoadByUrlType) {
+  let actor = await loadActorByUrl(actorUrl, fetchType)
+  // Orphan actor (not associated to an account of channel) so recreate it
+  if (actor && (!actor.Account && !actor.VideoChannel)) {
+    await actor.destroy()
+    actor = null
+  }
+  return actor
+}
+function getOrCreateAPOwner (actorObject: ActivityPubActor, actorUrl: string) {
+  const accountAttributedTo = actorObject.attributedTo.find(a => a.type === 'Person')
+  if (!accountAttributedTo) throw new Error('Cannot find account attributed to video channel ' + actorUrl)
+  if (checkUrlsSameHost(accountAttributedTo.id, actorUrl) !== true) {
+    throw new Error(`Account attributed to ${accountAttributedTo.id} does not have the same host than actor url ${actorUrl}`)
+  }
+  try {
+    // Don't recurse another time
+    const recurseIfNeeded = false
+    return getOrCreateAPActor(accountAttributedTo.id, 'all', recurseIfNeeded)
+  } catch (err) {
+    logger.error('Cannot get or create account attributed to video channel ' + actorUrl)
+    throw new Error(err)
+  }
+}
+async function scheduleOutboxFetchIfNeeded (actor: MActor, created: boolean, refreshed: boolean, updateCollections: boolean) {
+  if ((created === true || refreshed === true) && updateCollections === true) {
+    const payload = { uri: actor.outboxUrl, type: 'activity' as 'activity' }
+    await JobQueue.Instance.createJobWithPromise({ type: 'activitypub-http-fetcher', payload })
+  }
+}
+async function schedulePlaylistFetchIfNeeded (actor: MActorAccountId, created: boolean, accountPlaylistsUrl: string) {
+  // We created a new account: fetch the playlists
+  if (created === true && actor.Account && accountPlaylistsUrl) {
+    const payload = { uri: accountPlaylistsUrl, type: 'account-playlists' as 'account-playlists' }
+    await JobQueue.Instance.createJobWithPromise({ type: 'activitypub-http-fetcher', payload })
+  }
+}
diff --git a/server/lib/activitypub/actors/image.ts b/server/lib/activitypub/actors/image.ts
new file mode 100644
index 000000000..443ad0a63
--- /dev/null
+++ b/server/lib/activitypub/actors/image.ts
@@ -0,0 +1,94 @@
+import { Transaction } from 'sequelize/types'
+import { logger } from '@server/helpers/logger'
+import { ActorImageModel } from '@server/models/actor/actor-image'
+import { MActorImage, MActorImages } from '@server/types/models'
+import { ActorImageType } from '@shared/models'
+type ImageInfo = {
+  name: string
+  fileUrl: string
+  height: number
+  width: number
+  onDisk?: boolean
+}
+async function updateActorImageInstance (actor: MActorImages, type: ActorImageType, imageInfo: ImageInfo | null, t: Transaction) {
+  const oldImageModel = type === ActorImageType.AVATAR
+    ? actor.Avatar
+    : actor.Banner
+  if (oldImageModel) {
+    // Don't update the avatar if the file URL did not change
+    if (imageInfo?.fileUrl && oldImageModel.fileUrl === imageInfo.fileUrl) return actor
+    try {
+      await oldImageModel.destroy({ transaction: t })
+      setActorImage(actor, type, null)
+    } catch (err) {
+      logger.error('Cannot remove old actor image of actor %s.', actor.url, { err })
+    }
+  }
+  if (imageInfo) {
+    const imageModel = await ActorImageModel.create({
+      filename: imageInfo.name,
+      onDisk: imageInfo.onDisk ?? false,
+      fileUrl: imageInfo.fileUrl,
+      height: imageInfo.height,
+      width: imageInfo.width,
+      type
+    }, { transaction: t })
+    setActorImage(actor, type, imageModel)
+  }
+  return actor
+}
+async function deleteActorImageInstance (actor: MActorImages, type: ActorImageType, t: Transaction) {
+  try {
+    if (type === ActorImageType.AVATAR) {
+      await actor.Avatar.destroy({ transaction: t })
+      actor.avatarId = null
+      actor.Avatar = null
+    } else {
+      await actor.Banner.destroy({ transaction: t })
+      actor.bannerId = null
+      actor.Banner = null
+    }
+  } catch (err) {
+    logger.error('Cannot remove old image of actor %s.', actor.url, { err })
+  }
+  return actor
+}
+// ---------------------------------------------------------------------------
+export {
+  ImageInfo,
+  updateActorImageInstance,
+  deleteActorImageInstance
+}
+// ---------------------------------------------------------------------------
+function setActorImage (actorModel: MActorImages, type: ActorImageType, imageModel: MActorImage) {
+  const id = imageModel
+    ? imageModel.id
+    : null
+  if (type === ActorImageType.AVATAR) {
+    actorModel.avatarId = id
+    actorModel.Avatar = imageModel
+  } else {
+    actorModel.bannerId = id
+    actorModel.Banner = imageModel
+  }
+  return actorModel
+}
diff --git a/server/lib/activitypub/actors/index.ts b/server/lib/activitypub/actors/index.ts
new file mode 100644
index 000000000..5ee2a6f1a
--- /dev/null
+++ b/server/lib/activitypub/actors/index.ts
@@ -0,0 +1,6 @@
+export * from './get'
+export * from './image'
+export * from './keys'
+export * from './refresh'
+export * from './updater'
+export * from './webfinger'
diff --git a/server/lib/activitypub/actors/keys.ts b/server/lib/activitypub/actors/keys.ts
new file mode 100644
index 000000000..c3d18abd8
--- /dev/null
+++ b/server/lib/activitypub/actors/keys.ts
@@ -0,0 +1,16 @@
+import { createPrivateAndPublicKeys } from '@server/helpers/peertube-crypto'
+import { MActor } from '@server/types/models'
+// Set account keys, this could be long so process after the account creation and do not block the client
+async function generateAndSaveActorKeys <T extends MActor> (actor: T) {
+  const { publicKey, privateKey } = await createPrivateAndPublicKeys()
+  actor.publicKey = publicKey
+  actor.privateKey = privateKey
+  return actor.save()
+}
+export {
+  generateAndSaveActorKeys
+}
diff --git a/server/lib/activitypub/actors/refresh.ts b/server/lib/activitypub/actors/refresh.ts
new file mode 100644
index 000000000..b2fe3932f
--- /dev/null
+++ b/server/lib/activitypub/actors/refresh.ts
@@ -0,0 +1,81 @@
+import { logger, loggerTagsFactory } from '@server/helpers/logger'
+import { PromiseCache } from '@server/helpers/promise-cache'
+import { PeerTubeRequestError } from '@server/helpers/requests'
+import { ActorLoadByUrlType } from '@server/lib/model-loaders'
+import { ActorModel } from '@server/models/actor/actor'
+import { MActorAccountChannelId, MActorFull } from '@server/types/models'
+import { HttpStatusCode } from '@shared/core-utils'
+import { fetchRemoteActor } from './shared'
+import { APActorUpdater } from './updater'
+import { getUrlFromWebfinger } from './webfinger'
+type RefreshResult <T> = Promise<{ actor: T | MActorFull, refreshed: boolean }>
+type RefreshOptions <T> = {
+  actor: T
+  fetchedType: ActorLoadByUrlType
+}
+const promiseCache = new PromiseCache(doRefresh, (options: RefreshOptions<MActorFull | MActorAccountChannelId>) => options.actor.url)
+function refreshActorIfNeeded <T extends MActorFull | MActorAccountChannelId> (options: RefreshOptions<T>): RefreshResult <T> {
+  const actorArg = options.actor
+  if (!actorArg.isOutdated()) return Promise.resolve({ actor: actorArg, refreshed: false })
+  return promiseCache.run(options)
+}
+export {
+  refreshActorIfNeeded
+}
+// ---------------------------------------------------------------------------
+async function doRefresh <T extends MActorFull | MActorAccountChannelId> (options: RefreshOptions<T>): RefreshResult <MActorFull> {
+  const { actor: actorArg, fetchedType } = options
+  // We need more attributes
+  const actor = fetchedType === 'all'
+    ? actorArg as MActorFull
+    : await ActorModel.loadByUrlAndPopulateAccountAndChannel(actorArg.url)
+  const lTags = loggerTagsFactory('ap', 'actor', 'refresh', actor.url)
+  logger.info('Refreshing actor %s.', actor.url, lTags())
+  try {
+    const actorUrl = await getActorUrl(actor)
+    const { actorObject } = await fetchRemoteActor(actorUrl)
+    if (actorObject === undefined) {
+      logger.warn('Cannot fetch remote actor in refresh actor.')
+      return { actor, refreshed: false }
+    }
+    const updater = new APActorUpdater(actorObject, actor)
+    await updater.update()
+    return { refreshed: true, actor }
+  } catch (err) {
+    if ((err as PeerTubeRequestError).statusCode === HttpStatusCode.NOT_FOUND_404) {
+      logger.info('Deleting actor %s because there is a 404 in refresh actor.', actor.url, lTags())
+      actor.Account
+        ? await actor.Account.destroy()
+        : await actor.VideoChannel.destroy()
+      return { actor: undefined, refreshed: false }
+    }
+    logger.warn('Cannot refresh actor %s.', actor.url, { err, ...lTags() })
+    return { actor, refreshed: false }
+  }
+}
+function getActorUrl (actor: MActorFull) {
+  return getUrlFromWebfinger(actor.preferredUsername + '@' + actor.getHost())
+    .catch(err => {
+      logger.warn('Cannot get actor URL from webfinger, keeping the old one.', err)
+      return actor.url
+    })
+}
diff --git a/server/lib/activitypub/actors/shared/creator.ts b/server/lib/activitypub/actors/shared/creator.ts
new file mode 100644
index 000000000..999aed97d
--- /dev/null
+++ b/server/lib/activitypub/actors/shared/creator.ts
@@ -0,0 +1,149 @@
+import { Op, Transaction } from 'sequelize'
+import { sequelizeTypescript } from '@server/initializers/database'
+import { AccountModel } from '@server/models/account/account'
+import { ActorModel } from '@server/models/actor/actor'
+import { ServerModel } from '@server/models/server/server'
+import { VideoChannelModel } from '@server/models/video/video-channel'
+import { MAccount, MAccountDefault, MActor, MActorFullActor, MActorId, MActorImages, MChannel, MServer } from '@server/types/models'
+import { ActivityPubActor, ActorImageType } from '@shared/models'
+import { updateActorImageInstance } from '../image'
+import { getActorAttributesFromObject, getActorDisplayNameFromObject, getImageInfoFromObject } from './object-to-model-attributes'
+import { fetchActorFollowsCount } from './url-to-object'
+export class APActorCreator {
+  constructor (
+    private readonly actorObject: ActivityPubActor,
+    private readonly ownerActor?: MActorFullActor
+  ) {
+  }
+  async create (): Promise<MActorFullActor> {
+    const { followersCount, followingCount } = await fetchActorFollowsCount(this.actorObject)
+    const actorInstance = new ActorModel(getActorAttributesFromObject(this.actorObject, followersCount, followingCount))
+    return sequelizeTypescript.transaction(async t => {
+      const server = await this.setServer(actorInstance, t)
+      await this.setImageIfNeeded(actorInstance, ActorImageType.AVATAR, t)
+      await this.setImageIfNeeded(actorInstance, ActorImageType.BANNER, t)
+      const { actorCreated, created } = await this.saveActor(actorInstance, t)
+      await this.tryToFixActorUrlIfNeeded(actorCreated, actorInstance, created, t)
+      if (actorCreated.type === 'Person' || actorCreated.type === 'Application') { // Account or PeerTube instance
+        actorCreated.Account = await this.saveAccount(actorCreated, t) as MAccountDefault
+        actorCreated.Account.Actor = actorCreated
+      }
+      if (actorCreated.type === 'Group') { // Video channel
+        const channel = await this.saveVideoChannel(actorCreated, t)
+        actorCreated.VideoChannel = Object.assign(channel, { Actor: actorCreated, Account: this.ownerActor.Account })
+      }
+      actorCreated.Server = server
+      return actorCreated
+    })
+  }
+  private async setServer (actor: MActor, t: Transaction) {
+    const actorHost = new URL(actor.url).host
+    const serverOptions = {
+      where: {
+        host: actorHost
+      },
+      defaults: {
+        host: actorHost
+      },
+      transaction: t
+    }
+    const [ server ] = await ServerModel.findOrCreate(serverOptions)
+    // Save our new account in database
+    actor.serverId = server.id
+    return server as MServer
+  }
+  private async setImageIfNeeded (actor: MActor, type: ActorImageType, t: Transaction) {
+    const imageInfo = getImageInfoFromObject(this.actorObject, type)
+    if (!imageInfo) return
+    return updateActorImageInstance(actor as MActorImages, type, imageInfo, t)
+  }
+  private async saveActor (actor: MActor, t: Transaction) {
+    // Force the actor creation using findOrCreate() instead of save()
+    // Sometimes Sequelize skips the save() when it thinks the instance already exists
+    // (which could be false in a retried query)
+    const [ actorCreated, created ] = await ActorModel.findOrCreate<MActorFullActor>({
+      defaults: actor.toJSON(),
+      where: {
+        [Op.or]: [
+          {
+            url: actor.url
+          },
+          {
+            serverId: actor.serverId,
+            preferredUsername: actor.preferredUsername
+          }
+        ]
+      },
+      transaction: t
+    })
+    return { actorCreated, created }
+  }
+  private async tryToFixActorUrlIfNeeded (actorCreated: MActor, newActor: MActor, created: boolean, t: Transaction) {
+    // Try to fix non HTTPS accounts of remote instances that fixed their URL afterwards
+    if (created !== true && actorCreated.url !== newActor.url) {
+      // Only fix http://example.com/account/djidane to https://example.com/account/djidane
+      if (actorCreated.url.replace(/^http:\/\//, '') !== newActor.url.replace(/^https:\/\//, '')) {
+        throw new Error(`Actor from DB with URL ${actorCreated.url} does not correspond to actor ${newActor.url}`)
+      }
+      actorCreated.url = newActor.url
+      await actorCreated.save({ transaction: t })
+    }
+  }
+  private async saveAccount (actor: MActorId, t: Transaction) {
+    const [ accountCreated ] = await AccountModel.findOrCreate({
+      defaults: {
+        name: getActorDisplayNameFromObject(this.actorObject),
+        description: this.actorObject.summary,
+        actorId: actor.id
+      },
+      where: {
+        actorId: actor.id
+      },
+      transaction: t
+    })
+    return accountCreated as MAccount
+  }
+  private async saveVideoChannel (actor: MActorId, t: Transaction) {
+    const [ videoChannelCreated ] = await VideoChannelModel.findOrCreate({
+      defaults: {
+        name: getActorDisplayNameFromObject(this.actorObject),
+        description: this.actorObject.summary,
+        support: this.actorObject.support,
+        actorId: actor.id,
+        accountId: this.ownerActor.Account.id
+      },
+      where: {
+        actorId: actor.id
+      },
+      transaction: t
+    })
+    return videoChannelCreated as MChannel
+  }
+}
diff --git a/server/lib/activitypub/actors/shared/index.ts b/server/lib/activitypub/actors/shared/index.ts
new file mode 100644
index 000000000..52af1a8e1
--- /dev/null
+++ b/server/lib/activitypub/actors/shared/index.ts
@@ -0,0 +1,3 @@
+export * from './creator'
+export * from './object-to-model-attributes'
+export * from './url-to-object'
diff --git a/server/lib/activitypub/actors/shared/object-to-model-attributes.ts b/server/lib/activitypub/actors/shared/object-to-model-attributes.ts
new file mode 100644
index 000000000..1612b3ad0
--- /dev/null
+++ b/server/lib/activitypub/actors/shared/object-to-model-attributes.ts
@@ -0,0 +1,70 @@
+import { getLowercaseExtension } from '@server/helpers/core-utils'
+import { isActivityPubUrlValid } from '@server/helpers/custom-validators/activitypub/misc'
+import { buildUUID } from '@server/helpers/uuid'
+import { MIMETYPES } from '@server/initializers/constants'
+import { ActorModel } from '@server/models/actor/actor'
+import { FilteredModelAttributes } from '@server/types'
+import { ActivityPubActor, ActorImageType } from '@shared/models'
+function getActorAttributesFromObject (
+  actorObject: ActivityPubActor,
+  followersCount: number,
+  followingCount: number
+): FilteredModelAttributes<ActorModel> {
+  return {
+    type: actorObject.type,
+    preferredUsername: actorObject.preferredUsername,
+    url: actorObject.id,
+    publicKey: actorObject.publicKey.publicKeyPem,
+    privateKey: null,
+    followersCount,
+    followingCount,
+    inboxUrl: actorObject.inbox,
+    outboxUrl: actorObject.outbox,
+    followersUrl: actorObject.followers,
+    followingUrl: actorObject.following,
+    sharedInboxUrl: actorObject.endpoints?.sharedInbox
+      ? actorObject.endpoints.sharedInbox
+      : null
+  }
+}
+function getImageInfoFromObject (actorObject: ActivityPubActor, type: ActorImageType) {
+  const mimetypes = MIMETYPES.IMAGE
+  const icon = type === ActorImageType.AVATAR
+    ? actorObject.icon
+    : actorObject.image
+  if (!icon || icon.type !== 'Image' || !isActivityPubUrlValid(icon.url)) return undefined
+  let extension: string
+  if (icon.mediaType) {
+    extension = mimetypes.MIMETYPE_EXT[icon.mediaType]
+  } else {
+    const tmp = getLowercaseExtension(icon.url)
+    if (mimetypes.EXT_MIMETYPE[tmp] !== undefined) extension = tmp
+  }
+  if (!extension) return undefined
+  return {
+    name: buildUUID() + extension,
+    fileUrl: icon.url,
+    height: icon.height,
+    width: icon.width,
+    type
+  }
+}
+function getActorDisplayNameFromObject (actorObject: ActivityPubActor) {
+  return actorObject.name || actorObject.preferredUsername
+}
+export {
+  getActorAttributesFromObject,
+  getImageInfoFromObject,
+  getActorDisplayNameFromObject
+}
diff --git a/server/lib/activitypub/actors/shared/url-to-object.ts b/server/lib/activitypub/actors/shared/url-to-object.ts
new file mode 100644
index 000000000..f4f16b044
--- /dev/null
+++ b/server/lib/activitypub/actors/shared/url-to-object.ts
@@ -0,0 +1,54 @@
+import { checkUrlsSameHost } from '@server/helpers/activitypub'
+import { sanitizeAndCheckActorObject } from '@server/helpers/custom-validators/activitypub/actor'
+import { logger } from '@server/helpers/logger'
+import { doJSONRequest } from '@server/helpers/requests'
+import { ActivityPubActor, ActivityPubOrderedCollection } from '@shared/models'
+async function fetchRemoteActor (actorUrl: string): Promise<{ statusCode: number, actorObject: ActivityPubActor }> {
+  logger.info('Fetching remote actor %s.', actorUrl)
+  const { body, statusCode } = await doJSONRequest<ActivityPubActor>(actorUrl, { activityPub: true })
+  if (sanitizeAndCheckActorObject(body) === false) {
+    logger.debug('Remote actor JSON is not valid.', { actorJSON: body })
+    return { actorObject: undefined, statusCode: statusCode }
+  }
+  if (checkUrlsSameHost(body.id, actorUrl) !== true) {
+    logger.warn('Actor url %s has not the same host than its AP id %s', actorUrl, body.id)
+    return { actorObject: undefined, statusCode: statusCode }
+  }
+  return {
+    statusCode,
+    actorObject: body
+  }
+}
+async function fetchActorFollowsCount (actorObject: ActivityPubActor) {
+  const followersCount = await fetchActorTotalItems(actorObject.followers)
+  const followingCount = await fetchActorTotalItems(actorObject.following)
+  return { followersCount, followingCount }
+}
+// ---------------------------------------------------------------------------
+export {
+  fetchActorFollowsCount,
+  fetchRemoteActor
+}
+// ---------------------------------------------------------------------------
+async function fetchActorTotalItems (url: string) {
+  try {
+    const { body } = await doJSONRequest<ActivityPubOrderedCollection<unknown>>(url, { activityPub: true })
+    return body.totalItems || 0
+  } catch (err) {
+    logger.warn('Cannot fetch remote actor count %s.', url, { err })
+    return 0
+  }
+}
diff --git a/server/lib/activitypub/actors/updater.ts b/server/lib/activitypub/actors/updater.ts
new file mode 100644
index 000000000..de5e03eee
--- /dev/null
+++ b/server/lib/activitypub/actors/updater.ts
@@ -0,0 +1,90 @@
+import { resetSequelizeInstance, runInReadCommittedTransaction } from '@server/helpers/database-utils'
+import { logger } from '@server/helpers/logger'
+import { VideoChannelModel } from '@server/models/video/video-channel'
+import { MAccount, MActor, MActorFull, MChannel } from '@server/types/models'
+import { ActivityPubActor, ActorImageType } from '@shared/models'
+import { updateActorImageInstance } from './image'
+import { fetchActorFollowsCount } from './shared'
+import { getImageInfoFromObject } from './shared/object-to-model-attributes'
+export class APActorUpdater {
+  private accountOrChannel: MAccount | MChannel
+  private readonly actorFieldsSave: object
+  private readonly accountOrChannelFieldsSave: object
+  constructor (
+    private readonly actorObject: ActivityPubActor,
+    private readonly actor: MActorFull
+  ) {
+    this.actorFieldsSave = this.actor.toJSON()
+    if (this.actorObject.type === 'Group') this.accountOrChannel = this.actor.VideoChannel
+    else this.accountOrChannel = this.actor.Account
+    this.accountOrChannelFieldsSave = this.accountOrChannel.toJSON()
+  }
+  async update () {
+    const avatarInfo = getImageInfoFromObject(this.actorObject, ActorImageType.AVATAR)
+    const bannerInfo = getImageInfoFromObject(this.actorObject, ActorImageType.BANNER)
+    try {
+      await this.updateActorInstance(this.actor, this.actorObject)
+      this.accountOrChannel.name = this.actorObject.name || this.actorObject.preferredUsername
+      this.accountOrChannel.description = this.actorObject.summary
+      if (this.accountOrChannel instanceof VideoChannelModel) this.accountOrChannel.support = this.actorObject.support
+      await runInReadCommittedTransaction(async t => {
+        await updateActorImageInstance(this.actor, ActorImageType.AVATAR, avatarInfo, t)
+        await updateActorImageInstance(this.actor, ActorImageType.BANNER, bannerInfo, t)
+      })
+      await runInReadCommittedTransaction(async t => {
+        await this.actor.save({ transaction: t })
+        await this.accountOrChannel.save({ transaction: t })
+      })
+      logger.info('Remote account %s updated', this.actorObject.url)
+    } catch (err) {
+      if (this.actor !== undefined && this.actorFieldsSave !== undefined) {
+        resetSequelizeInstance(this.actor, this.actorFieldsSave)
+      }
+      if (this.accountOrChannel !== undefined && this.accountOrChannelFieldsSave !== undefined) {
+        resetSequelizeInstance(this.accountOrChannel, this.accountOrChannelFieldsSave)
+      }
+      // This is just a debug because we will retry the insert
+      logger.debug('Cannot update the remote account.', { err })
+      throw err
+    }
+  }
+  private async updateActorInstance (actorInstance: MActor, actorObject: ActivityPubActor) {
+    const { followersCount, followingCount } = await fetchActorFollowsCount(actorObject)
+    actorInstance.type = actorObject.type
+    actorInstance.preferredUsername = actorObject.preferredUsername
+    actorInstance.url = actorObject.id
+    actorInstance.publicKey = actorObject.publicKey.publicKeyPem
+    actorInstance.followersCount = followersCount
+    actorInstance.followingCount = followingCount
+    actorInstance.inboxUrl = actorObject.inbox
+    actorInstance.outboxUrl = actorObject.outbox
+    actorInstance.followersUrl = actorObject.followers
+    actorInstance.followingUrl = actorObject.following
+    if (actorObject.published) actorInstance.remoteCreatedAt = new Date(actorObject.published)
+    if (actorObject.endpoints?.sharedInbox) {
+      actorInstance.sharedInboxUrl = actorObject.endpoints.sharedInbox
+    }
+    // Force actor update
+    actorInstance.changed('updatedAt', true)
+  }
+}
diff --git a/server/lib/activitypub/actors/webfinger.ts b/server/lib/activitypub/actors/webfinger.ts
new file mode 100644
index 000000000..1c7ec4717
--- /dev/null
+++ b/server/lib/activitypub/actors/webfinger.ts
@@ -0,0 +1,67 @@
+import * as WebFinger from 'webfinger.js'
+import { isProdInstance } from '@server/helpers/core-utils'
+import { isActivityPubUrlValid } from '@server/helpers/custom-validators/activitypub/misc'
+import { REQUEST_TIMEOUT, WEBSERVER } from '@server/initializers/constants'
+import { ActorModel } from '@server/models/actor/actor'
+import { MActorFull } from '@server/types/models'
+import { WebFingerData } from '@shared/models'
+const webfinger = new WebFinger({
+  webfist_fallback: false,
+  tls_only: isProdInstance(),
+  uri_fallback: false,
+  request_timeout: REQUEST_TIMEOUT
+})
+async function loadActorUrlOrGetFromWebfinger (uriArg: string) {
+  // Handle strings like @toto@example.com
+  const uri = uriArg.startsWith('@') ? uriArg.slice(1) : uriArg
+  const [ name, host ] = uri.split('@')
+  let actor: MActorFull
+  if (!host || host === WEBSERVER.HOST) {
+    actor = await ActorModel.loadLocalByName(name)
+  } else {
+    actor = await ActorModel.loadByNameAndHost(name, host)
+  }
+  if (actor) return actor.url
+  return getUrlFromWebfinger(uri)
+}
+async function getUrlFromWebfinger (uri: string) {
+  const webfingerData: WebFingerData = await webfingerLookup(uri)
+  return getLinkOrThrow(webfingerData)
+}
+// ---------------------------------------------------------------------------
+export {
+  getUrlFromWebfinger,
+  loadActorUrlOrGetFromWebfinger
+}
+// ---------------------------------------------------------------------------
+function getLinkOrThrow (webfingerData: WebFingerData) {
+  if (Array.isArray(webfingerData.links) === false) throw new Error('WebFinger links is not an array.')
+  const selfLink = webfingerData.links.find(l => l.rel === 'self')
+  if (selfLink === undefined || isActivityPubUrlValid(selfLink.href) === false) {
+    throw new Error('Cannot find self link or href is not a valid URL.')
+  }
+  return selfLink.href
+}
+function webfingerLookup (nameWithHost: string) {
+  return new Promise<WebFingerData>((res, rej) => {
+    webfinger.lookup(nameWithHost, (err, p) => {
+      if (err) return rej(err)
+      return res(p.object)
+    })
+  })
+}
diff --git a/server/lib/activitypub/audience.ts b/server/lib/activitypub/audience.ts
index 2986714d3..d0558f191 100644
--- a/server/lib/activitypub/audience.ts
+++ b/server/lib/activitypub/audience.ts
@@ -1,7 +1,7 @@
 import { Transaction } from 'sequelize'
 import { ActivityAudience } from '../../../shared/models/activitypub'
 import { ACTIVITY_PUB } from '../../initializers/constants'
-import { ActorModel } from '../../models/activitypub/actor'
+import { ActorModel } from '../../models/actor/actor'
 import { VideoModel } from '../../models/video/video'
 import { VideoShareModel } from '../../models/video/video-share'
 import { MActorFollowersUrl, MActorLight, MActorUrl, MCommentOwner, MCommentOwnerVideo, MVideoId } from '../../types/models'
diff --git a/server/lib/activitypub/cache-file.ts b/server/lib/activitypub/cache-file.ts
index 2e6dd34e0..a16d2cd93 100644
--- a/server/lib/activitypub/cache-file.ts
+++ b/server/lib/activitypub/cache-file.ts
@@ -1,54 +1,27 @@
-import { CacheFileObject } from '../../../shared/index'
-import { VideoRedundancyModel } from '../../models/redundancy/video-redundancy'
 import { Transaction } from 'sequelize'
-import { VideoStreamingPlaylistType } from '../../../shared/models/videos/video-streaming-playlist.type'
 import { MActorId, MVideoRedundancy, MVideoWithAllFiles } from '@server/types/models'
+import { CacheFileObject } from '../../../shared/index'
+import { VideoStreamingPlaylistType } from '../../../shared/models/videos/video-streaming-playlist.type'
+import { VideoRedundancyModel } from '../../models/redundancy/video-redundancy'
-function cacheFileActivityObjectToDBAttributes (cacheFileObject: CacheFileObject, video: MVideoWithAllFiles, byActor: MActorId) {
+async function createOrUpdateCacheFile (cacheFileObject: CacheFileObject, video: MVideoWithAllFiles, byActor: MActorId, t: Transaction) {
+  const redundancyModel = await VideoRedundancyModel.loadByUrl(cacheFileObject.id, t)
-  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 {
+  if (redundancyModel) {
-      expiresOn: cacheFileObject.expires ? new Date(cacheFileObject.expires) : null,
+    return updateCacheFile(cacheFileObject, redundancyModel, video, byActor, t)
-      url: cacheFileObject.id,
-      fileUrl: url.href,
-      strategy: null,
-      videoStreamingPlaylistId: playlist.id,
-      actorId: byActor.id
-    }
  }
-  const url = cacheFileObject.url
+  return createCacheFile(cacheFileObject, video, byActor, t)
-  const videoFile = video.VideoFiles.find(f => {
-    return f.resolution === url.height && f.fps === url.fps
-  })
-  if (!videoFile) throw new Error(`Cannot find video file ${url.height} ${url.fps} of video ${video.url}`)
-  return {
-    expiresOn: cacheFileObject.expires ? new Date(cacheFileObject.expires) : null,
-    url: cacheFileObject.id,
-    fileUrl: url.href,
-    strategy: null,
-    videoFileId: videoFile.id,
-    actorId: byActor.id
-  }
 }
-async function createOrUpdateCacheFile (cacheFileObject: CacheFileObject, video: MVideoWithAllFiles, byActor: MActorId, t: Transaction) {
+// ---------------------------------------------------------------------------
-  const redundancyModel = await VideoRedundancyModel.loadByUrl(cacheFileObject.id, t)
-  if (!redundancyModel) {
+export {
-    await createCacheFile(cacheFileObject, video, byActor, t)
+  createOrUpdateCacheFile
-  } else {
-    await updateCacheFile(cacheFileObject, redundancyModel, video, byActor, t)
-  }
 }
+// ---------------------------------------------------------------------------
 function createCacheFile (cacheFileObject: CacheFileObject, video: MVideoWithAllFiles, byActor: MActorId, t: Transaction) {
  const attributes = cacheFileActivityObjectToDBAttributes(cacheFileObject, video, byActor)
@@ -74,9 +47,37 @@ function updateCacheFile (
  return redundancyModel.save({ transaction: t })
 }
-export {
+function cacheFileActivityObjectToDBAttributes (cacheFileObject: CacheFileObject, video: MVideoWithAllFiles, byActor: MActorId) {
-  createOrUpdateCacheFile,
-  createCacheFile,
+  if (cacheFileObject.url.mediaType === 'application/x-mpegURL') {
-  updateCacheFile,
+    const url = cacheFileObject.url
-  cacheFileActivityObjectToDBAttributes
+    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: cacheFileObject.expires ? new Date(cacheFileObject.expires) : null,
+      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
+  })
+  if (!videoFile) throw new Error(`Cannot find video file ${url.height} ${url.fps} of video ${video.url}`)
+  return {
+    expiresOn: cacheFileObject.expires ? new Date(cacheFileObject.expires) : null,
+    url: cacheFileObject.id,
+    fileUrl: url.href,
+    strategy: null,
+    videoFileId: videoFile.id,
+    actorId: byActor.id
+  }
 }
diff --git a/server/lib/activitypub/crawl.ts b/server/lib/activitypub/crawl.ts
index 278abf7de..cd117f571 100644
--- a/server/lib/activitypub/crawl.ts
+++ b/server/lib/activitypub/crawl.ts
@@ -3,7 +3,7 @@ import { URL } from 'url'
 import { ActivityPubOrderedCollection } from '../../../shared/models/activitypub'
 import { logger } from '../../helpers/logger'
 import { doJSONRequest } from '../../helpers/requests'
-import { ACTIVITY_PUB, REQUEST_TIMEOUT, WEBSERVER } from '../../initializers/constants'
+import { ACTIVITY_PUB, WEBSERVER } from '../../initializers/constants'
 type HandlerFunction<T> = (items: T[]) => (Promise<any> | Bluebird<any>)
 type CleanerFunction = (startedDate: Date) => (Promise<any> | Bluebird<any>)
@@ -13,10 +13,7 @@ async function crawlCollectionPage <T> (argUrl: string, handler: HandlerFunction
  logger.info('Crawling ActivityPub data on %s.', url)
-  const options = {
+  const options = { activityPub: true }
-    activityPub: true,
-    timeout: REQUEST_TIMEOUT
-  }
  const startDate = new Date()
diff --git a/server/lib/activitypub/follow.ts b/server/lib/activitypub/follow.ts
index 351499bd1..c1bd667e0 100644
--- a/server/lib/activitypub/follow.ts
+++ b/server/lib/activitypub/follow.ts
@@ -1,12 +1,13 @@
-import { MActorFollowActors } from '../../types/models'
+import { Transaction } from 'sequelize'
+import { getServerActor } from '@server/models/application/application'
+import { logger } from '../../helpers/logger'
 import { CONFIG } from '../../initializers/config'
 import { SERVER_ACTOR_NAME } from '../../initializers/constants'
-import { JobQueue } from '../job-queue'
-import { logger } from '../../helpers/logger'
 import { ServerModel } from '../../models/server/server'
-import { getServerActor } from '@server/models/application/application'
+import { MActorFollowActors } from '../../types/models'
+import { JobQueue } from '../job-queue'
-async function autoFollowBackIfNeeded (actorFollow: MActorFollowActors) {
+async function autoFollowBackIfNeeded (actorFollow: MActorFollowActors, transaction?: Transaction) {
  if (!CONFIG.FOLLOWINGS.INSTANCE.AUTO_FOLLOW_BACK.ENABLED) return
  const follower = actorFollow.ActorFollower
@@ -16,7 +17,7 @@ async function autoFollowBackIfNeeded (actorFollow: MActorFollowActors) {
    const me = await getServerActor()
-    const server = await ServerModel.load(follower.serverId)
+    const server = await ServerModel.load(follower.serverId, transaction)
    const host = server.host
    const payload = {
diff --git a/server/lib/activitypub/outbox.ts b/server/lib/activitypub/outbox.ts
new file mode 100644
index 000000000..ecdc33a77
--- /dev/null
+++ b/server/lib/activitypub/outbox.ts
@@ -0,0 +1,24 @@
+import { logger } from '@server/helpers/logger'
+import { ActorModel } from '@server/models/actor/actor'
+import { getServerActor } from '@server/models/application/application'
+import { JobQueue } from '../job-queue'
+async function addFetchOutboxJob (actor: Pick<ActorModel, 'id' | 'outboxUrl'>) {
+  // Don't fetch ourselves
+  const serverActor = await getServerActor()
+  if (serverActor.id === actor.id) {
+    logger.error('Cannot fetch our own outbox!')
+    return undefined
+  }
+  const payload = {
+    uri: actor.outboxUrl,
+    type: 'activity' as 'activity'
+  }
+  return JobQueue.Instance.createJob({ type: 'activitypub-http-fetcher', payload })
+}
+export {
+  addFetchOutboxJob
+}
diff --git a/server/lib/activitypub/playlist.ts b/server/lib/activitypub/playlist.ts
deleted file mode 100644
index 7166c68a6..000000000
--- a/server/lib/activitypub/playlist.ts
+++ /dev/null
@@ -1,204 +0,0 @@
-import * as Bluebird from 'bluebird'
-import { HttpStatusCode } from '../../../shared/core-utils/miscs/http-error-codes'
-import { PlaylistElementObject } from '../../../shared/models/activitypub/objects/playlist-element-object'
-import { PlaylistObject } from '../../../shared/models/activitypub/objects/playlist-object'
-import { VideoPlaylistPrivacy } from '../../../shared/models/videos/playlist/video-playlist-privacy.model'
-import { checkUrlsSameHost } from '../../helpers/activitypub'
-import { isPlaylistElementObjectValid, isPlaylistObjectValid } from '../../helpers/custom-validators/activitypub/playlist'
-import { isArray } from '../../helpers/custom-validators/misc'
-import { logger } from '../../helpers/logger'
-import { doJSONRequest, PeerTubeRequestError } from '../../helpers/requests'
-import { ACTIVITY_PUB, CRAWL_REQUEST_CONCURRENCY } from '../../initializers/constants'
-import { sequelizeTypescript } from '../../initializers/database'
-import { VideoPlaylistModel } from '../../models/video/video-playlist'
-import { VideoPlaylistElementModel } from '../../models/video/video-playlist-element'
-import { MAccountDefault, MAccountId, MVideoId } from '../../types/models'
-import { MVideoPlaylist, MVideoPlaylistId, MVideoPlaylistOwner } from '../../types/models/video/video-playlist'
-import { FilteredModelAttributes } from '../../types/sequelize'
-import { createPlaylistMiniatureFromUrl } from '../thumbnail'
-import { getOrCreateActorAndServerAndModel } from './actor'
-import { crawlCollectionPage } from './crawl'
-import { getOrCreateVideoAndAccountAndChannel } from './videos'
-function playlistObjectToDBAttributes (playlistObject: PlaylistObject, byAccount: MAccountId, to: string[]) {
-  const privacy = to.includes(ACTIVITY_PUB.PUBLIC)
-    ? 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: MVideoPlaylistId, video: MVideoId) {
-  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: MAccountDefault) {
-  await Bluebird.map(playlistUrls, async playlistUrl => {
-    try {
-      const exists = await VideoPlaylistModel.doesPlaylistExist(playlistUrl)
-      if (exists === true) return
-      // Fetch url
-      const { body } = await doJSONRequest<PlaylistObject>(playlistUrl, { 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: MAccountId, 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<MVideoPlaylist>(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({ downloadUrl: playlistObject.icon.url, playlist: refreshedPlaylist })
-      await refreshedPlaylist.setAndSaveThumbnail(thumbnailModel, undefined)
-    } catch (err) {
-      logger.warn('Cannot generate thumbnail of %s.', playlistObject.id, { err })
-    }
-  } else if (refreshedPlaylist.hasThumbnail()) {
-    await refreshedPlaylist.Thumbnail.destroy()
-    refreshedPlaylist.Thumbnail = null
-  }
-  return resetVideoPlaylistElements(accItems, refreshedPlaylist)
-}
-async function refreshVideoPlaylistIfNeeded (videoPlaylist: MVideoPlaylistOwner): Promise<MVideoPlaylistOwner> {
-  if (!videoPlaylist.isOutdated()) return videoPlaylist
-  try {
-    const { playlistObject } = await fetchRemoteVideoPlaylist(videoPlaylist.url)
-    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) {
-    if ((err as PeerTubeRequestError).statusCode === HttpStatusCode.NOT_FOUND_404) {
-      logger.info('Cannot refresh remote video playlist %s: it does not exist anymore. Deleting it.', videoPlaylist.url)
-      await videoPlaylist.destroy()
-      return undefined
-    }
-    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: MVideoPlaylist) {
-  const elementsToCreate: FilteredModelAttributes<VideoPlaylistElementModel>[] = []
-  await Bluebird.map(elementUrls, async elementUrl => {
-    try {
-      const { body } = await doJSONRequest<PlaylistElementObject>(elementUrl, { 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 }> {
-  logger.info('Fetching remote playlist %s.', playlistUrl)
-  const { body, statusCode } = await doJSONRequest<any>(playlistUrl, { activityPub: true })
-  if (isPlaylistObjectValid(body) === false || checkUrlsSameHost(body.id, playlistUrl) !== true) {
-    logger.debug('Remote video playlist JSON is not valid.', { body })
-    return { statusCode, playlistObject: undefined }
-  }
-  return { statusCode, playlistObject: body }
-}
diff --git a/server/lib/activitypub/playlists/create-update.ts b/server/lib/activitypub/playlists/create-update.ts
new file mode 100644
index 000000000..ea3e61ac5
--- /dev/null
+++ b/server/lib/activitypub/playlists/create-update.ts
@@ -0,0 +1,156 @@
+import * as Bluebird from 'bluebird'
+import { getAPId } from '@server/helpers/activitypub'
+import { isArray } from '@server/helpers/custom-validators/misc'
+import { logger, loggerTagsFactory } from '@server/helpers/logger'
+import { CRAWL_REQUEST_CONCURRENCY } from '@server/initializers/constants'
+import { sequelizeTypescript } from '@server/initializers/database'
+import { updatePlaylistMiniatureFromUrl } from '@server/lib/thumbnail'
+import { VideoPlaylistModel } from '@server/models/video/video-playlist'
+import { VideoPlaylistElementModel } from '@server/models/video/video-playlist-element'
+import { FilteredModelAttributes } from '@server/types'
+import { MThumbnail, MVideoPlaylist, MVideoPlaylistFull, MVideoPlaylistVideosLength } from '@server/types/models'
+import { AttributesOnly } from '@shared/core-utils'
+import { PlaylistObject } from '@shared/models'
+import { getOrCreateAPActor } from '../actors'
+import { crawlCollectionPage } from '../crawl'
+import { getOrCreateAPVideo } from '../videos'
+import {
+  fetchRemotePlaylistElement,
+  fetchRemoteVideoPlaylist,
+  playlistElementObjectToDBAttributes,
+  playlistObjectToDBAttributes
+} from './shared'
+const lTags = loggerTagsFactory('ap', 'video-playlist')
+async function createAccountPlaylists (playlistUrls: string[]) {
+  await Bluebird.map(playlistUrls, async playlistUrl => {
+    try {
+      const exists = await VideoPlaylistModel.doesPlaylistExist(playlistUrl)
+      if (exists === true) return
+      const { playlistObject } = await fetchRemoteVideoPlaylist(playlistUrl)
+      if (playlistObject === undefined) {
+        throw new Error(`Cannot refresh remote playlist ${playlistUrl}: invalid body.`)
+      }
+      return createOrUpdateVideoPlaylist(playlistObject)
+    } catch (err) {
+      logger.warn('Cannot add playlist element %s.', playlistUrl, { err, ...lTags(playlistUrl) })
+    }
+  }, { concurrency: CRAWL_REQUEST_CONCURRENCY })
+}
+async function createOrUpdateVideoPlaylist (playlistObject: PlaylistObject, to?: string[]) {
+  const playlistAttributes = playlistObjectToDBAttributes(playlistObject, to || playlistObject.to)
+  await setVideoChannel(playlistObject, playlistAttributes)
+  const [ upsertPlaylist ] = await VideoPlaylistModel.upsert<MVideoPlaylistVideosLength>(playlistAttributes, { returning: true })
+  const playlistElementUrls = await fetchElementUrls(playlistObject)
+  // Refetch playlist from DB since elements fetching could be long in time
+  const playlist = await VideoPlaylistModel.loadWithAccountAndChannel(upsertPlaylist.id, null)
+  await updatePlaylistThumbnail(playlistObject, playlist)
+  const elementsLength = await rebuildVideoPlaylistElements(playlistElementUrls, playlist)
+  playlist.setVideosLength(elementsLength)
+  return playlist
+}
+// ---------------------------------------------------------------------------
+export {
+  createAccountPlaylists,
+  createOrUpdateVideoPlaylist
+}
+// ---------------------------------------------------------------------------
+async function setVideoChannel (playlistObject: PlaylistObject, playlistAttributes: AttributesOnly<VideoPlaylistModel>) {
+  if (!isArray(playlistObject.attributedTo) || playlistObject.attributedTo.length !== 1) {
+    throw new Error('Not attributed to for playlist object ' + getAPId(playlistObject))
+  }
+  const actor = await getOrCreateAPActor(playlistObject.attributedTo[0], 'all')
+  if (!actor.VideoChannel) {
+    logger.warn('Playlist "attributedTo" %s is not a video channel.', playlistObject.id, { playlistObject, ...lTags(playlistObject.id) })
+    return
+  }
+  playlistAttributes.videoChannelId = actor.VideoChannel.id
+  playlistAttributes.ownerAccountId = actor.VideoChannel.Account.id
+}
+async function fetchElementUrls (playlistObject: PlaylistObject) {
+  let accItems: string[] = []
+  await crawlCollectionPage<string>(playlistObject.id, items => {
+    accItems = accItems.concat(items)
+    return Promise.resolve()
+  })
+  return accItems
+}
+async function updatePlaylistThumbnail (playlistObject: PlaylistObject, playlist: MVideoPlaylistFull) {
+  if (playlistObject.icon) {
+    let thumbnailModel: MThumbnail
+    try {
+      thumbnailModel = await updatePlaylistMiniatureFromUrl({ downloadUrl: playlistObject.icon.url, playlist })
+      await playlist.setAndSaveThumbnail(thumbnailModel, undefined)
+    } catch (err) {
+      logger.warn('Cannot set thumbnail of %s.', playlistObject.id, { err, ...lTags(playlistObject.id, playlist.uuid, playlist.url) })
+      if (thumbnailModel) await thumbnailModel.removeThumbnail()
+    }
+    return
+  }
+  // Playlist does not have an icon, destroy existing one
+  if (playlist.hasThumbnail()) {
+    await playlist.Thumbnail.destroy()
+    playlist.Thumbnail = null
+  }
+}
+async function rebuildVideoPlaylistElements (elementUrls: string[], playlist: MVideoPlaylist) {
+  const elementsToCreate = await buildElementsDBAttributes(elementUrls, playlist)
+  await sequelizeTypescript.transaction(async t => {
+    await VideoPlaylistElementModel.deleteAllOf(playlist.id, t)
+    for (const element of elementsToCreate) {
+      await VideoPlaylistElementModel.create(element, { transaction: t })
+    }
+  })
+  logger.info('Rebuilt playlist %s with %s elements.', playlist.url, elementsToCreate.length, lTags(playlist.uuid, playlist.url))
+  return elementsToCreate.length
+}
+async function buildElementsDBAttributes (elementUrls: string[], playlist: MVideoPlaylist) {
+  const elementsToCreate: FilteredModelAttributes<VideoPlaylistElementModel>[] = []
+  await Bluebird.map(elementUrls, async elementUrl => {
+    try {
+      const { elementObject } = await fetchRemotePlaylistElement(elementUrl)
+      const { video } = await getOrCreateAPVideo({ videoObject: { id: elementObject.url }, fetchType: 'only-video' })
+      elementsToCreate.push(playlistElementObjectToDBAttributes(elementObject, playlist, video))
+    } catch (err) {
+      logger.warn('Cannot add playlist element %s.', elementUrl, { err, ...lTags(playlist.uuid, playlist.url) })
+    }
+  }, { concurrency: CRAWL_REQUEST_CONCURRENCY })
+  return elementsToCreate
+}
diff --git a/server/lib/activitypub/playlists/get.ts b/server/lib/activitypub/playlists/get.ts
new file mode 100644
index 000000000..2c19c503a
--- /dev/null
+++ b/server/lib/activitypub/playlists/get.ts
@@ -0,0 +1,35 @@
+import { getAPId } from '@server/helpers/activitypub'
+import { VideoPlaylistModel } from '@server/models/video/video-playlist'
+import { MVideoPlaylistFullSummary } from '@server/types/models'
+import { APObject } from '@shared/models'
+import { createOrUpdateVideoPlaylist } from './create-update'
+import { scheduleRefreshIfNeeded } from './refresh'
+import { fetchRemoteVideoPlaylist } from './shared'
+async function getOrCreateAPVideoPlaylist (playlistObjectArg: APObject): Promise<MVideoPlaylistFullSummary> {
+  const playlistUrl = getAPId(playlistObjectArg)
+  const playlistFromDatabase = await VideoPlaylistModel.loadByUrlWithAccountAndChannelSummary(playlistUrl)
+  if (playlistFromDatabase) {
+    scheduleRefreshIfNeeded(playlistFromDatabase)
+    return playlistFromDatabase
+  }
+  const { playlistObject } = await fetchRemoteVideoPlaylist(playlistUrl)
+  if (!playlistObject) throw new Error('Cannot fetch remote playlist with url: ' + playlistUrl)
+  // playlistUrl is just an alias/rediraction, so process object id instead
+  if (playlistObject.id !== playlistUrl) return getOrCreateAPVideoPlaylist(playlistObject)
+  const playlistCreated = await createOrUpdateVideoPlaylist(playlistObject)
+  return playlistCreated
+}
+// ---------------------------------------------------------------------------
+export {
+  getOrCreateAPVideoPlaylist
+}
diff --git a/server/lib/activitypub/playlists/index.ts b/server/lib/activitypub/playlists/index.ts
new file mode 100644
index 000000000..e2470a674
--- /dev/null
+++ b/server/lib/activitypub/playlists/index.ts
@@ -0,0 +1,3 @@
+export * from './get'
+export * from './create-update'
+export * from './refresh'
diff --git a/server/lib/activitypub/playlists/refresh.ts b/server/lib/activitypub/playlists/refresh.ts
new file mode 100644
index 000000000..ef3cb3fe4
--- /dev/null
+++ b/server/lib/activitypub/playlists/refresh.ts
@@ -0,0 +1,53 @@
+import { logger, loggerTagsFactory } from '@server/helpers/logger'
+import { PeerTubeRequestError } from '@server/helpers/requests'
+import { JobQueue } from '@server/lib/job-queue'
+import { MVideoPlaylist, MVideoPlaylistOwner } from '@server/types/models'
+import { HttpStatusCode } from '@shared/core-utils'
+import { createOrUpdateVideoPlaylist } from './create-update'
+import { fetchRemoteVideoPlaylist } from './shared'
+function scheduleRefreshIfNeeded (playlist: MVideoPlaylist) {
+  if (!playlist.isOutdated()) return
+  JobQueue.Instance.createJob({ type: 'activitypub-refresher', payload: { type: 'video-playlist', url: playlist.url } })
+}
+async function refreshVideoPlaylistIfNeeded (videoPlaylist: MVideoPlaylistOwner): Promise<MVideoPlaylistOwner> {
+  if (!videoPlaylist.isOutdated()) return videoPlaylist
+  const lTags = loggerTagsFactory('ap', 'video-playlist', 'refresh', videoPlaylist.uuid, videoPlaylist.url)
+  logger.info('Refreshing playlist %s.', videoPlaylist.url, lTags())
+  try {
+    const { playlistObject } = await fetchRemoteVideoPlaylist(videoPlaylist.url)
+    if (playlistObject === undefined) {
+      logger.warn('Cannot refresh remote playlist %s: invalid body.', videoPlaylist.url, lTags())
+      await videoPlaylist.setAsRefreshed()
+      return videoPlaylist
+    }
+    await createOrUpdateVideoPlaylist(playlistObject)
+    return videoPlaylist
+  } catch (err) {
+    if ((err as PeerTubeRequestError).statusCode === HttpStatusCode.NOT_FOUND_404) {
+      logger.info('Cannot refresh not existing playlist %s. Deleting it.', videoPlaylist.url, lTags())
+      await videoPlaylist.destroy()
+      return undefined
+    }
+    logger.warn('Cannot refresh video playlist %s.', videoPlaylist.url, { err, ...lTags() })
+    await videoPlaylist.setAsRefreshed()
+    return videoPlaylist
+  }
+}
+export {
+  scheduleRefreshIfNeeded,
+  refreshVideoPlaylistIfNeeded
+}
diff --git a/server/lib/activitypub/playlists/shared/index.ts b/server/lib/activitypub/playlists/shared/index.ts
new file mode 100644
index 000000000..a217f2291
--- /dev/null
+++ b/server/lib/activitypub/playlists/shared/index.ts
@@ -0,0 +1,2 @@
+export * from './object-to-model-attributes'
+export * from './url-to-object'
diff --git a/server/lib/activitypub/playlists/shared/object-to-model-attributes.ts b/server/lib/activitypub/playlists/shared/object-to-model-attributes.ts
new file mode 100644
index 000000000..70fd335bc
--- /dev/null
+++ b/server/lib/activitypub/playlists/shared/object-to-model-attributes.ts
@@ -0,0 +1,40 @@
+import { ACTIVITY_PUB } from '@server/initializers/constants'
+import { VideoPlaylistModel } from '@server/models/video/video-playlist'
+import { VideoPlaylistElementModel } from '@server/models/video/video-playlist-element'
+import { MVideoId, MVideoPlaylistId } from '@server/types/models'
+import { AttributesOnly } from '@shared/core-utils'
+import { PlaylistElementObject, PlaylistObject, VideoPlaylistPrivacy } from '@shared/models'
+function playlistObjectToDBAttributes (playlistObject: PlaylistObject, to: string[]) {
+  const privacy = to.includes(ACTIVITY_PUB.PUBLIC)
+    ? VideoPlaylistPrivacy.PUBLIC
+    : VideoPlaylistPrivacy.UNLISTED
+  return {
+    name: playlistObject.name,
+    description: playlistObject.content,
+    privacy,
+    url: playlistObject.id,
+    uuid: playlistObject.uuid,
+    ownerAccountId: null,
+    videoChannelId: null,
+    createdAt: new Date(playlistObject.published),
+    updatedAt: new Date(playlistObject.updated)
+  } as AttributesOnly<VideoPlaylistModel>
+}
+function playlistElementObjectToDBAttributes (elementObject: PlaylistElementObject, videoPlaylist: MVideoPlaylistId, video: MVideoId) {
+  return {
+    position: elementObject.position,
+    url: elementObject.id,
+    startTimestamp: elementObject.startTimestamp || null,
+    stopTimestamp: elementObject.stopTimestamp || null,
+    videoPlaylistId: videoPlaylist.id,
+    videoId: video.id
+  } as AttributesOnly<VideoPlaylistElementModel>
+}
+export {
+  playlistObjectToDBAttributes,
+  playlistElementObjectToDBAttributes
+}
diff --git a/server/lib/activitypub/playlists/shared/url-to-object.ts b/server/lib/activitypub/playlists/shared/url-to-object.ts
new file mode 100644
index 000000000..ec8c01255
--- /dev/null
+++ b/server/lib/activitypub/playlists/shared/url-to-object.ts
@@ -0,0 +1,47 @@
+import { isArray } from 'lodash'
+import { checkUrlsSameHost } from '@server/helpers/activitypub'
+import { isPlaylistElementObjectValid, isPlaylistObjectValid } from '@server/helpers/custom-validators/activitypub/playlist'
+import { logger, loggerTagsFactory } from '@server/helpers/logger'
+import { doJSONRequest } from '@server/helpers/requests'
+import { PlaylistElementObject, PlaylistObject } from '@shared/models'
+async function fetchRemoteVideoPlaylist (playlistUrl: string): Promise<{ statusCode: number, playlistObject: PlaylistObject }> {
+  const lTags = loggerTagsFactory('ap', 'video-playlist', playlistUrl)
+  logger.info('Fetching remote playlist %s.', playlistUrl, lTags())
+  const { body, statusCode } = await doJSONRequest<any>(playlistUrl, { activityPub: true })
+  if (isPlaylistObjectValid(body) === false || checkUrlsSameHost(body.id, playlistUrl) !== true) {
+    logger.debug('Remote video playlist JSON is not valid.', { body, ...lTags() })
+    return { statusCode, playlistObject: undefined }
+  }
+  if (!isArray(body.to)) {
+    logger.debug('Remote video playlist JSON does not have a valid audience.', { body, ...lTags() })
+    return { statusCode, playlistObject: undefined }
+  }
+  return { statusCode, playlistObject: body }
+}
+async function fetchRemotePlaylistElement (elementUrl: string): Promise<{ statusCode: number, elementObject: PlaylistElementObject }> {
+  const lTags = loggerTagsFactory('ap', 'video-playlist', 'element', elementUrl)
+  logger.debug('Fetching remote playlist element %s.', elementUrl, lTags())
+  const { body, statusCode } = await doJSONRequest<PlaylistElementObject>(elementUrl, { activityPub: true })
+  if (!isPlaylistElementObjectValid(body)) throw new Error(`Invalid body in fetch 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}`)
+  }
+  return { statusCode, elementObject: body }
+}
+export {
+  fetchRemoteVideoPlaylist,
+  fetchRemotePlaylistElement
+}
diff --git a/server/lib/activitypub/process/process-accept.ts b/server/lib/activitypub/process/process-accept.ts
index 1799829f8..077b01eda 100644
--- a/server/lib/activitypub/process/process-accept.ts
+++ b/server/lib/activitypub/process/process-accept.ts
@@ -1,8 +1,8 @@
 import { ActivityAccept } from '../../../../shared/models/activitypub'
-import { ActorFollowModel } from '../../../models/activitypub/actor-follow'
+import { ActorFollowModel } from '../../../models/actor/actor-follow'
-import { addFetchOutboxJob } from '../actor'
 import { APProcessorOptions } from '../../../types/activitypub-processor.model'
 import { MActorDefault, MActorSignature } from '../../../types/models'
+import { addFetchOutboxJob } from '../outbox'
 async function processAcceptActivity (options: APProcessorOptions<ActivityAccept>) {
  const { byActor: targetActor, inboxActor } = options
diff --git a/server/lib/activitypub/process/process-announce.ts b/server/lib/activitypub/process/process-announce.ts
index 63082466e..ec23c705e 100644
--- a/server/lib/activitypub/process/process-announce.ts
+++ b/server/lib/activitypub/process/process-announce.ts
@@ -3,7 +3,7 @@ import { retryTransactionWrapper } from '../../../helpers/database-utils'
 import { sequelizeTypescript } from '../../../initializers/database'
 import { VideoShareModel } from '../../../models/video/video-share'
 import { forwardVideoRelatedActivity } from '../send/utils'
-import { getOrCreateVideoAndAccountAndChannel } from '../videos'
+import { getOrCreateAPVideo } from '../videos'
 import { Notifier } from '../../notifier'
 import { logger } from '../../../helpers/logger'
 import { APProcessorOptions } from '../../../types/activitypub-processor.model'
@@ -32,7 +32,7 @@ async function processVideoShare (actorAnnouncer: MActorSignature, activity: Act
  let videoCreated: boolean
  try {
-    const result = await getOrCreateVideoAndAccountAndChannel({ videoObject: objectUri })
+    const result = await getOrCreateAPVideo({ videoObject: objectUri })
    video = result.video
    videoCreated = result.created
  } catch (err) {
diff --git a/server/lib/activitypub/process/process-create.ts b/server/lib/activitypub/process/process-create.ts
index 9cded4dec..70e048d6e 100644
--- a/server/lib/activitypub/process/process-create.ts
+++ b/server/lib/activitypub/process/process-create.ts
@@ -1,3 +1,4 @@
+import { isBlockedByServerOrAccount } from '@server/lib/blocklist'
 import { isRedundancyAccepted } from '@server/lib/redundancy'
 import { ActivityCreate, CacheFileObject, VideoObject } from '../../../../shared'
 import { PlaylistObject } from '../../../../shared/models/activitypub/objects/playlist-object'
@@ -9,11 +10,10 @@ import { APProcessorOptions } from '../../../types/activitypub-processor.model'
 import { MActorSignature, MCommentOwnerVideo, MVideoAccountLightBlacklistAllFiles } from '../../../types/models'
 import { Notifier } from '../../notifier'
 import { createOrUpdateCacheFile } from '../cache-file'
-import { createOrUpdateVideoPlaylist } from '../playlist'
+import { createOrUpdateVideoPlaylist } from '../playlists'
 import { forwardVideoRelatedActivity } from '../send/utils'
 import { resolveThread } from '../video-comments'
-import { getOrCreateVideoAndAccountAndChannel } from '../videos'
+import { getOrCreateAPVideo } from '../videos'
-import { isBlockedByServerOrAccount } from '@server/lib/blocklist'
 async function processCreateActivity (options: APProcessorOptions<ActivityCreate>) {
  const { activity, byActor } = options
@@ -55,7 +55,7 @@ async function processCreateVideo (activity: ActivityCreate, notify: boolean) {
  const videoToCreateData = activity.object as VideoObject
  const syncParam = { likes: false, dislikes: false, shares: false, comments: false, thumbnail: true, refreshVideo: false }
-  const { video, created } = await getOrCreateVideoAndAccountAndChannel({ videoObject: videoToCreateData, syncParam })
+  const { video, created } = await getOrCreateAPVideo({ videoObject: videoToCreateData, syncParam })
  if (created && notify) Notifier.Instance.notifyOnNewVideoIfNeeded(video)
@@ -67,7 +67,7 @@ async function processCreateCacheFile (activity: ActivityCreate, byActor: MActor
  const cacheFile = activity.object as CacheFileObject
-  const { video } = await getOrCreateVideoAndAccountAndChannel({ videoObject: cacheFile.object })
+  const { video } = await getOrCreateAPVideo({ videoObject: cacheFile.object })
  await sequelizeTypescript.transaction(async t => {
    return createOrUpdateCacheFile(cacheFile, video, byActor, t)
@@ -128,5 +128,5 @@ async function processCreatePlaylist (activity: ActivityCreate, byActor: MActorS
  if (!byAccount) throw new Error('Cannot create video playlist with the non account actor ' + byActor.url)
-  await createOrUpdateVideoPlaylist(playlistObject, byAccount, activity.to)
+  await createOrUpdateVideoPlaylist(playlistObject, activity.to)
 }
diff --git a/server/lib/activitypub/process/process-delete.ts b/server/lib/activitypub/process/process-delete.ts
index 88a968318..1d2279df5 100644
--- a/server/lib/activitypub/process/process-delete.ts
+++ b/server/lib/activitypub/process/process-delete.ts
@@ -2,7 +2,7 @@ import { ActivityDelete } from '../../../../shared/models/activitypub'
 import { retryTransactionWrapper } from '../../../helpers/database-utils'
 import { logger } from '../../../helpers/logger'
 import { sequelizeTypescript } from '../../../initializers/database'
-import { ActorModel } from '../../../models/activitypub/actor'
+import { ActorModel } from '../../../models/actor/actor'
 import { VideoModel } from '../../../models/video/video'
 import { VideoCommentModel } from '../../../models/video/video-comment'
 import { VideoPlaylistModel } from '../../../models/video/video-playlist'
@@ -16,7 +16,6 @@ import {
  MChannelActor,
  MCommentOwnerVideo
 } from '../../../types/models'
-import { markCommentAsDeleted } from '../../video-comment'
 import { forwardVideoRelatedActivity } from '../send/utils'
 async function processDeleteActivity (options: APProcessorOptions<ActivityDelete>) {
@@ -130,7 +129,7 @@ async function processDeleteVideoChannel (videoChannelToRemove: MChannelActor) {
 function processDeleteVideoComment (byActor: MActorSignature, videoComment: MCommentOwnerVideo, activity: ActivityDelete) {
  // Already deleted
-  if (videoComment.isDeleted()) return
+  if (videoComment.isDeleted()) return Promise.resolve()
  logger.debug('Removing remote video comment "%s".', videoComment.url)
@@ -139,11 +138,9 @@ function processDeleteVideoComment (byActor: MActorSignature, videoComment: MCom
      throw new Error(`Account ${byActor.url} does not own video comment ${videoComment.url} or video ${videoComment.Video.url}`)
    }
-    await sequelizeTypescript.transaction(async t => {
+    videoComment.markAsDeleted()
-      markCommentAsDeleted(videoComment)
-      await videoComment.save()
+    await videoComment.save({ transaction: t })
-    })
    if (videoComment.Video.isOwned()) {
      // Don't resend the activity to the sender
diff --git a/server/lib/activitypub/process/process-dislike.ts b/server/lib/activitypub/process/process-dislike.ts
index 089c7b881..ecc57cd10 100644
--- a/server/lib/activitypub/process/process-dislike.ts
+++ b/server/lib/activitypub/process/process-dislike.ts
@@ -6,7 +6,7 @@ import { AccountVideoRateModel } from '../../../models/account/account-video-rat
 import { APProcessorOptions } from '../../../types/activitypub-processor.model'
 import { MActorSignature } from '../../../types/models'
 import { forwardVideoRelatedActivity } from '../send/utils'
-import { getOrCreateVideoAndAccountAndChannel } from '../videos'
+import { getOrCreateAPVideo } from '../videos'
 async function processDislikeActivity (options: APProcessorOptions<ActivityCreate | ActivityDislike>) {
  const { activity, byActor } = options
@@ -30,7 +30,7 @@ async function processDislike (activity: ActivityCreate | ActivityDislike, byAct
  if (!byAccount) throw new Error('Cannot create dislike with the non account actor ' + byActor.url)
-  const { video } = await getOrCreateVideoAndAccountAndChannel({ videoObject: dislikeObject })
+  const { video } = await getOrCreateAPVideo({ videoObject: dislikeObject })
  return sequelizeTypescript.transaction(async t => {
    const existingRate = await AccountVideoRateModel.loadByAccountAndVideoOrUrl(byAccount.id, video.id, activity.id, t)
diff --git a/server/lib/activitypub/process/process-follow.ts b/server/lib/activitypub/process/process-follow.ts
index 38d684512..f85238f8e 100644
--- a/server/lib/activitypub/process/process-follow.ts
+++ b/server/lib/activitypub/process/process-follow.ts
@@ -1,17 +1,17 @@
+import { getServerActor } from '@server/models/application/application'
 import { ActivityFollow } from '../../../../shared/models/activitypub'
+import { getAPId } from '../../../helpers/activitypub'
 import { retryTransactionWrapper } from '../../../helpers/database-utils'
 import { logger } from '../../../helpers/logger'
-import { sequelizeTypescript } from '../../../initializers/database'
-import { ActorModel } from '../../../models/activitypub/actor'
-import { ActorFollowModel } from '../../../models/activitypub/actor-follow'
-import { sendAccept, sendReject } from '../send'
-import { Notifier } from '../../notifier'
-import { getAPId } from '../../../helpers/activitypub'
 import { CONFIG } from '../../../initializers/config'
+import { sequelizeTypescript } from '../../../initializers/database'
+import { ActorModel } from '../../../models/actor/actor'
+import { ActorFollowModel } from '../../../models/actor/actor-follow'
 import { APProcessorOptions } from '../../../types/activitypub-processor.model'
 import { MActorFollowActors, MActorSignature } from '../../../types/models'
+import { Notifier } from '../../notifier'
 import { autoFollowBackIfNeeded } from '../follow'
-import { getServerActor } from '@server/models/application/application'
+import { sendAccept, sendReject } from '../send'
 async function processFollowActivity (options: APProcessorOptions<ActivityFollow>) {
  const { activity, byActor } = options
@@ -43,7 +43,7 @@ async function processFollow (byActor: MActorSignature, activityId: string, targ
    if (isFollowingInstance && CONFIG.FOLLOWERS.INSTANCE.ENABLED === false) {
      logger.info('Rejecting %s because instance followers are disabled.', targetActor.url)
-      await sendReject(activityId, byActor, targetActor)
+      sendReject(activityId, byActor, targetActor)
      return { actorFollow: undefined as MActorFollowActors }
    }
@@ -84,8 +84,9 @@ async function processFollow (byActor: MActorSignature, activityId: string, targ
    // Target sends to actor he accepted the follow request
    if (actorFollow.state === 'accepted') {
-      await sendAccept(actorFollow)
+      sendAccept(actorFollow)
-      await autoFollowBackIfNeeded(actorFollow)
+      await autoFollowBackIfNeeded(actorFollow, t)
    }
    return { actorFollow, created, isFollowingInstance, targetActor }
diff --git a/server/lib/activitypub/process/process-like.ts b/server/lib/activitypub/process/process-like.ts
index 8688b3b47..cd4e86cbb 100644
--- a/server/lib/activitypub/process/process-like.ts
+++ b/server/lib/activitypub/process/process-like.ts
@@ -6,7 +6,7 @@ import { AccountVideoRateModel } from '../../../models/account/account-video-rat
 import { APProcessorOptions } from '../../../types/activitypub-processor.model'
 import { MActorSignature } from '../../../types/models'
 import { forwardVideoRelatedActivity } from '../send/utils'
-import { getOrCreateVideoAndAccountAndChannel } from '../videos'
+import { getOrCreateAPVideo } from '../videos'
 async function processLikeActivity (options: APProcessorOptions<ActivityLike>) {
  const { activity, byActor } = options
@@ -27,7 +27,7 @@ async function processLikeVideo (byActor: MActorSignature, activity: ActivityLik
  const byAccount = byActor.Account
  if (!byAccount) throw new Error('Cannot create like with the non account actor ' + byActor.url)
-  const { video } = await getOrCreateVideoAndAccountAndChannel({ videoObject: videoUrl })
+  const { video } = await getOrCreateAPVideo({ videoObject: videoUrl })
  return sequelizeTypescript.transaction(async t => {
    const existingRate = await AccountVideoRateModel.loadByAccountAndVideoOrUrl(byAccount.id, video.id, activity.id, t)
diff --git a/server/lib/activitypub/process/process-reject.ts b/server/lib/activitypub/process/process-reject.ts
index 03b669fd9..7f7ab305f 100644
--- a/server/lib/activitypub/process/process-reject.ts
+++ b/server/lib/activitypub/process/process-reject.ts
@@ -1,6 +1,6 @@
 import { ActivityReject } from '../../../../shared/models/activitypub/activity'
 import { sequelizeTypescript } from '../../../initializers/database'
-import { ActorFollowModel } from '../../../models/activitypub/actor-follow'
+import { ActorFollowModel } from '../../../models/actor/actor-follow'
 import { APProcessorOptions } from '../../../types/activitypub-processor.model'
 import { MActor } from '../../../types/models'
diff --git a/server/lib/activitypub/process/process-undo.ts b/server/lib/activitypub/process/process-undo.ts
index e520c2f0d..d4b2a795f 100644
--- a/server/lib/activitypub/process/process-undo.ts
+++ b/server/lib/activitypub/process/process-undo.ts
@@ -4,14 +4,14 @@ import { retryTransactionWrapper } from '../../../helpers/database-utils'
 import { logger } from '../../../helpers/logger'
 import { sequelizeTypescript } from '../../../initializers/database'
 import { AccountVideoRateModel } from '../../../models/account/account-video-rate'
-import { ActorModel } from '../../../models/activitypub/actor'
+import { ActorModel } from '../../../models/actor/actor'
-import { ActorFollowModel } from '../../../models/activitypub/actor-follow'
+import { ActorFollowModel } from '../../../models/actor/actor-follow'
 import { VideoRedundancyModel } from '../../../models/redundancy/video-redundancy'
 import { VideoShareModel } from '../../../models/video/video-share'
 import { APProcessorOptions } from '../../../types/activitypub-processor.model'
 import { MActorSignature } from '../../../types/models'
 import { forwardVideoRelatedActivity } from '../send/utils'
-import { getOrCreateVideoAndAccountAndChannel } from '../videos'
+import { getOrCreateAPVideo } from '../videos'
 async function processUndoActivity (options: APProcessorOptions<ActivityUndo>) {
  const { activity, byActor } = options
@@ -55,7 +55,7 @@ export {
 async function processUndoLike (byActor: MActorSignature, activity: ActivityUndo) {
  const likeActivity = activity.object as ActivityLike
-  const { video } = await getOrCreateVideoAndAccountAndChannel({ videoObject: likeActivity.object })
+  const { video } = await getOrCreateAPVideo({ videoObject: likeActivity.object })
  return sequelizeTypescript.transaction(async t => {
    if (!byActor.Account) throw new Error('Unknown account ' + byActor.url)
@@ -80,7 +80,7 @@ async function processUndoDislike (byActor: MActorSignature, activity: ActivityU
    ? activity.object
    : activity.object.object as DislikeObject
-  const { video } = await getOrCreateVideoAndAccountAndChannel({ videoObject: dislike.object })
+  const { video } = await getOrCreateAPVideo({ videoObject: dislike.object })
  return sequelizeTypescript.transaction(async t => {
    if (!byActor.Account) throw new Error('Unknown account ' + byActor.url)
@@ -103,10 +103,10 @@ async function processUndoDislike (byActor: MActorSignature, activity: ActivityU
 async function processUndoCacheFile (byActor: MActorSignature, activity: ActivityUndo) {
  const cacheFileObject = activity.object.object as CacheFileObject
-  const { video } = await getOrCreateVideoAndAccountAndChannel({ videoObject: cacheFileObject.object })
+  const { video } = await getOrCreateAPVideo({ videoObject: cacheFileObject.object })
  return sequelizeTypescript.transaction(async t => {
-    const cacheFile = await VideoRedundancyModel.loadByUrl(cacheFileObject.id)
+    const cacheFile = await VideoRedundancyModel.loadByUrl(cacheFileObject.id, t)
    if (!cacheFile) {
      logger.debug('Cannot undo unknown video cache %s.', cacheFileObject.id)
      return
@@ -114,7 +114,7 @@ async function processUndoCacheFile (byActor: MActorSignature, activity: Activit
    if (cacheFile.actorId !== byActor.id) throw new Error('Cannot delete redundancy ' + cacheFile.url + ' of another actor.')
-    await cacheFile.destroy()
+    await cacheFile.destroy({ transaction: t })
    if (video.isOwned()) {
      // Don't resend the activity to the sender
diff --git a/server/lib/activitypub/process/process-update.ts b/server/lib/activitypub/process/process-update.ts
index 6df9b93b2..f40008a6b 100644
--- a/server/lib/activitypub/process/process-update.ts
+++ b/server/lib/activitypub/process/process-update.ts
@@ -1,23 +1,20 @@
+import { isRedundancyAccepted } from '@server/lib/redundancy'
 import { ActivityUpdate, CacheFileObject, VideoObject } from '../../../../shared/models/activitypub'
 import { ActivityPubActor } from '../../../../shared/models/activitypub/activitypub-actor'
-import { resetSequelizeInstance, retryTransactionWrapper } from '../../../helpers/database-utils'
+import { PlaylistObject } from '../../../../shared/models/activitypub/objects/playlist-object'
+import { isCacheFileObjectValid } from '../../../helpers/custom-validators/activitypub/cache-file'
+import { sanitizeAndCheckVideoTorrentObject } from '../../../helpers/custom-validators/activitypub/videos'
+import { retryTransactionWrapper } from '../../../helpers/database-utils'
 import { logger } from '../../../helpers/logger'
 import { sequelizeTypescript } from '../../../initializers/database'
-import { AccountModel } from '../../../models/account/account'
+import { ActorModel } from '../../../models/actor/actor'
-import { ActorModel } from '../../../models/activitypub/actor'
+import { APProcessorOptions } from '../../../types/activitypub-processor.model'
-import { VideoChannelModel } from '../../../models/video/video-channel'
+import { MActorFull, MActorSignature } from '../../../types/models'
-import { getImageInfoIfExists, updateActorImageInstance, updateActorInstance } from '../actor'
+import { APActorUpdater } from '../actors/updater'
-import { getOrCreateVideoAndAccountAndChannel, getOrCreateVideoChannelFromVideoObject, updateVideoFromAP } from '../videos'
-import { sanitizeAndCheckVideoTorrentObject } from '../../../helpers/custom-validators/activitypub/videos'
-import { isCacheFileObjectValid } from '../../../helpers/custom-validators/activitypub/cache-file'
 import { createOrUpdateCacheFile } from '../cache-file'
+import { createOrUpdateVideoPlaylist } from '../playlists'
 import { forwardVideoRelatedActivity } from '../send/utils'
-import { PlaylistObject } from '../../../../shared/models/activitypub/objects/playlist-object'
+import { APVideoUpdater, getOrCreateAPVideo } from '../videos'
-import { createOrUpdateVideoPlaylist } from '../playlist'
-import { APProcessorOptions } from '../../../types/activitypub-processor.model'
-import { MActorSignature, MAccountIdActor } from '../../../types/models'
-import { isRedundancyAccepted } from '@server/lib/redundancy'
-import { ActorImageType } from '@shared/models'
 async function processUpdateActivity (options: APProcessorOptions<ActivityUpdate>) {
  const { activity, byActor } = options
@@ -25,7 +22,7 @@ async function processUpdateActivity (options: APProcessorOptions<ActivityUpdate
  const objectType = activity.object.type
  if (objectType === 'Video') {
-    return retryTransactionWrapper(processUpdateVideo, byActor, activity)
+    return retryTransactionWrapper(processUpdateVideo, activity)
  }
  if (objectType === 'Person' || objectType === 'Application' || objectType === 'Group') {
@@ -55,7 +52,7 @@ export {
 // ---------------------------------------------------------------------------
-async function processUpdateVideo (actor: MActorSignature, activity: ActivityUpdate) {
+async function processUpdateVideo (activity: ActivityUpdate) {
  const videoObject = activity.object as VideoObject
  if (sanitizeAndCheckVideoTorrentObject(videoObject) === false) {
@@ -63,7 +60,7 @@ async function processUpdateVideo (actor: MActorSignature, activity: ActivityUpd
    return undefined
  }
-  const { video, created } = await getOrCreateVideoAndAccountAndChannel({
+  const { video, created } = await getOrCreateAPVideo({
    videoObject: videoObject.id,
    allowRefresh: false,
    fetchType: 'all'
@@ -71,20 +68,8 @@ async function processUpdateVideo (actor: MActorSignature, activity: ActivityUpd
  // We did not have this video, it has been created so no need to update
  if (created) return
-  // Load new channel
+  const updater = new APVideoUpdater(videoObject, video)
-  const channelActor = await getOrCreateVideoChannelFromVideoObject(videoObject)
+  return updater.update(activity.to)
-  const account = actor.Account as MAccountIdActor
-  account.Actor = actor
-  const updateOptions = {
-    video,
-    videoObject,
-    account,
-    channel: channelActor.VideoChannel,
-    overrideTo: activity.to
-  }
-  return updateVideoFromAP(updateOptions)
 }
 async function processUpdateCacheFile (byActor: MActorSignature, activity: ActivityUpdate) {
@@ -97,7 +82,7 @@ async function processUpdateCacheFile (byActor: MActorSignature, activity: Activ
    return undefined
  }
-  const { video } = await getOrCreateVideoAndAccountAndChannel({ videoObject: cacheFileObject.object })
+  const { video } = await getOrCreateAPVideo({ videoObject: cacheFileObject.object })
  await sequelizeTypescript.transaction(async t => {
    await createOrUpdateCacheFile(cacheFileObject, video, byActor, t)
@@ -111,56 +96,13 @@ async function processUpdateCacheFile (byActor: MActorSignature, activity: Activ
  }
 }
-async function processUpdateActor (actor: ActorModel, activity: ActivityUpdate) {
+async function processUpdateActor (actor: MActorFull, activity: ActivityUpdate) {
-  const actorAttributesToUpdate = activity.object as ActivityPubActor
+  const actorObject = activity.object as ActivityPubActor
-  logger.debug('Updating remote account "%s".', actorAttributesToUpdate.url)
+  logger.debug('Updating remote account "%s".', actorObject.url)
-  let accountOrChannelInstance: AccountModel | VideoChannelModel
-  let actorFieldsSave: object
-  let accountOrChannelFieldsSave: object
-  // Fetch icon?
+  const updater = new APActorUpdater(actorObject, actor)
-  const avatarInfo = getImageInfoIfExists(actorAttributesToUpdate, ActorImageType.AVATAR)
+  return updater.update()
-  const bannerInfo = getImageInfoIfExists(actorAttributesToUpdate, ActorImageType.BANNER)
-  try {
-    await sequelizeTypescript.transaction(async t => {
-      actorFieldsSave = actor.toJSON()
-      if (actorAttributesToUpdate.type === 'Group') accountOrChannelInstance = actor.VideoChannel
-      else accountOrChannelInstance = actor.Account
-      accountOrChannelFieldsSave = accountOrChannelInstance.toJSON()
-      await updateActorInstance(actor, actorAttributesToUpdate)
-      await updateActorImageInstance(actor, ActorImageType.AVATAR, avatarInfo, t)
-      await updateActorImageInstance(actor, ActorImageType.BANNER, bannerInfo, t)
-      await actor.save({ transaction: t })
-      accountOrChannelInstance.name = actorAttributesToUpdate.name || actorAttributesToUpdate.preferredUsername
-      accountOrChannelInstance.description = actorAttributesToUpdate.summary
-      if (accountOrChannelInstance instanceof VideoChannelModel) accountOrChannelInstance.support = actorAttributesToUpdate.support
-      await accountOrChannelInstance.save({ transaction: t })
-    })
-    logger.info('Remote account %s updated', actorAttributesToUpdate.url)
-  } catch (err) {
-    if (actor !== undefined && actorFieldsSave !== undefined) {
-      resetSequelizeInstance(actor, actorFieldsSave)
-    }
-    if (accountOrChannelInstance !== undefined && accountOrChannelFieldsSave !== undefined) {
-      resetSequelizeInstance(accountOrChannelInstance, accountOrChannelFieldsSave)
-    }
-    // This is just a debug because we will retry the insert
-    logger.debug('Cannot update the remote account.', { err })
-    throw err
-  }
 }
 async function processUpdatePlaylist (byActor: MActorSignature, activity: ActivityUpdate) {
@@ -169,5 +111,5 @@ async function processUpdatePlaylist (byActor: MActorSignature, activity: Activi
  if (!byAccount) throw new Error('Cannot update video playlist with the non account actor ' + byActor.url)
-  await createOrUpdateVideoPlaylist(playlistObject, byAccount, activity.to)
+  await createOrUpdateVideoPlaylist(playlistObject, activity.to)
 }
diff --git a/server/lib/activitypub/process/process-view.ts b/server/lib/activitypub/process/process-view.ts
index 84697673b..5593ee257 100644
--- a/server/lib/activitypub/process/process-view.ts
+++ b/server/lib/activitypub/process/process-view.ts
@@ -1,10 +1,10 @@
-import { getOrCreateVideoAndAccountAndChannel } from '../videos'
+import { getOrCreateAPVideo } from '../videos'
 import { forwardVideoRelatedActivity } from '../send/utils'
 import { Redis } from '../../redis'
 import { ActivityCreate, ActivityView, ViewObject } from '../../../../shared/models/activitypub'
 import { APProcessorOptions } from '../../../types/activitypub-processor.model'
 import { MActorSignature } from '../../../types/models'
-import { LiveManager } from '@server/lib/live-manager'
+import { LiveManager } from '@server/lib/live/live-manager'
 async function processViewActivity (options: APProcessorOptions<ActivityCreate | ActivityView>) {
  const { activity, byActor } = options
@@ -24,12 +24,11 @@ async function processCreateView (activity: ActivityView | ActivityCreate, byAct
    ? activity.object
    : (activity.object as ViewObject).object
-  const options = {
+  const { video } = await getOrCreateAPVideo({
    videoObject,
-    fetchType: 'only-video' as 'only-video',
+    fetchType: 'only-video',
-    allowRefresh: false as false
+    allowRefresh: false
-  }
+  })
-  const { video } = await getOrCreateVideoAndAccountAndChannel(options)
  if (!video.isLive) {
    await Redis.Instance.addVideoView(video.id)
diff --git a/server/lib/activitypub/process/process.ts b/server/lib/activitypub/process/process.ts
index 5cef75665..02a23d098 100644
--- a/server/lib/activitypub/process/process.ts
+++ b/server/lib/activitypub/process/process.ts
@@ -1,22 +1,22 @@
+import { StatsManager } from '@server/lib/stat-manager'
 import { Activity, ActivityType } from '../../../../shared/models/activitypub'
 import { checkUrlsSameHost, getAPId } from '../../../helpers/activitypub'
 import { logger } from '../../../helpers/logger'
+import { APProcessorOptions } from '../../../types/activitypub-processor.model'
+import { MActorDefault, MActorSignature } from '../../../types/models'
+import { getOrCreateAPActor } from '../actors'
 import { processAcceptActivity } from './process-accept'
 import { processAnnounceActivity } from './process-announce'
 import { processCreateActivity } from './process-create'
 import { processDeleteActivity } from './process-delete'
+import { processDislikeActivity } from './process-dislike'
+import { processFlagActivity } from './process-flag'
 import { processFollowActivity } from './process-follow'
 import { processLikeActivity } from './process-like'
 import { processRejectActivity } from './process-reject'
 import { processUndoActivity } from './process-undo'
 import { processUpdateActivity } from './process-update'
-import { getOrCreateActorAndServerAndModel } from '../actor'
-import { processDislikeActivity } from './process-dislike'
-import { processFlagActivity } from './process-flag'
 import { processViewActivity } from './process-view'
-import { APProcessorOptions } from '../../../types/activitypub-processor.model'
-import { MActorDefault, MActorSignature } from '../../../types/models'
-import { StatsManager } from '@server/lib/stat-manager'
 const processActivity: { [ P in ActivityType ]: (options: APProcessorOptions<Activity>) => Promise<any> } = {
  Create: processCreateActivity,
@@ -65,7 +65,7 @@ async function processActivities (
      continue
    }
-    const byActor = signatureActor || actorsCache[actorUrl] || await getOrCreateActorAndServerAndModel(actorUrl)
+    const byActor = signatureActor || actorsCache[actorUrl] || await getOrCreateAPActor(actorUrl)
    actorsCache[actorUrl] = byActor
    const activityProcessor = processActivity[activity.type]
diff --git a/server/lib/activitypub/send/send-delete.ts b/server/lib/activitypub/send/send-delete.ts
index e0acced18..d31f8c10b 100644
--- a/server/lib/activitypub/send/send-delete.ts
+++ b/server/lib/activitypub/send/send-delete.ts
@@ -2,7 +2,7 @@ import { Transaction } from 'sequelize'
 import { getServerActor } from '@server/models/application/application'
 import { ActivityAudience, ActivityDelete } from '../../../../shared/models/activitypub'
 import { logger } from '../../../helpers/logger'
-import { ActorModel } from '../../../models/activitypub/actor'
+import { ActorModel } from '../../../models/actor/actor'
 import { VideoCommentModel } from '../../../models/video/video-comment'
 import { VideoShareModel } from '../../../models/video/video-share'
 import { MActorUrl } from '../../../types/models'
diff --git a/server/lib/activitypub/send/send-view.ts b/server/lib/activitypub/send/send-view.ts
index 9254dc7c5..153e94295 100644
--- a/server/lib/activitypub/send/send-view.ts
+++ b/server/lib/activitypub/send/send-view.ts
@@ -2,7 +2,7 @@ import { Transaction } from 'sequelize'
 import { MActorAudience, MVideoImmutable, MVideoUrl } from '@server/types/models'
 import { ActivityAudience, ActivityView } from '../../../../shared/models/activitypub'
 import { logger } from '../../../helpers/logger'
-import { ActorModel } from '../../../models/activitypub/actor'
+import { ActorModel } from '../../../models/actor/actor'
 import { audiencify, getAudience } from '../audience'
 import { getLocalVideoViewActivityPubUrl } from '../url'
 import { sendVideoRelatedActivity } from './utils'
diff --git a/server/lib/activitypub/send/utils.ts b/server/lib/activitypub/send/utils.ts
index 85a9f009d..7cd8030e1 100644
--- a/server/lib/activitypub/send/utils.ts
+++ b/server/lib/activitypub/send/utils.ts
@@ -1,14 +1,14 @@
 import { Transaction } from 'sequelize'
+import { getServerActor } from '@server/models/application/application'
+import { ContextType } from '@shared/models/activitypub/context'
 import { Activity, ActivityAudience } from '../../../../shared/models/activitypub'
+import { afterCommitIfTransaction } from '../../../helpers/database-utils'
 import { logger } from '../../../helpers/logger'
-import { ActorModel } from '../../../models/activitypub/actor'
+import { ActorModel } from '../../../models/actor/actor'
-import { ActorFollowModel } from '../../../models/activitypub/actor-follow'
+import { ActorFollowModel } from '../../../models/actor/actor-follow'
+import { MActor, MActorId, MActorLight, MActorWithInboxes, MVideoAccountLight, MVideoId, MVideoImmutable } from '../../../types/models'
 import { JobQueue } from '../../job-queue'
 import { getActorsInvolvedInVideo, getAudienceFromFollowersOf, getRemoteVideoAudience } from '../audience'
-import { afterCommitIfTransaction } from '../../../helpers/database-utils'
-import { MActor, MActorId, MActorLight, MActorWithInboxes, MVideoAccountLight, MVideoId, MVideoImmutable } from '../../../types/models'
-import { getServerActor } from '@server/models/application/application'
-import { ContextType } from '@shared/models/activitypub/context'
 async function sendVideoRelatedActivity (activityBuilder: (audience: ActivityAudience) => Activity, options: {
  byActor: MActorLight
@@ -22,7 +22,9 @@ async function sendVideoRelatedActivity (activityBuilder: (audience: ActivityAud
  // Send to origin
  if (video.isOwned() === false) {
-    const accountActor = (video as MVideoAccountLight).VideoChannel?.Account?.Actor || await ActorModel.loadAccountActorByVideoId(video.id)
+    let accountActor: MActorLight = (video as MVideoAccountLight).VideoChannel?.Account?.Actor
+    if (!accountActor) accountActor = await ActorModel.loadAccountActorByVideoId(video.id, transaction)
    const audience = getRemoteVideoAudience(accountActor, actorsInvolvedInVideo)
    const activity = activityBuilder(audience)
diff --git a/server/lib/activitypub/share.ts b/server/lib/activitypub/share.ts
index c22fa0893..1ff01a175 100644
--- a/server/lib/activitypub/share.ts
+++ b/server/lib/activitypub/share.ts
@@ -7,7 +7,7 @@ import { doJSONRequest } from '../../helpers/requests'
 import { CRAWL_REQUEST_CONCURRENCY } from '../../initializers/constants'
 import { VideoShareModel } from '../../models/video/video-share'
 import { MChannelActorLight, MVideo, MVideoAccountLight, MVideoId } from '../../types/models/video'
-import { getOrCreateActorAndServerAndModel } from './actor'
+import { getOrCreateAPActor } from './actors'
 import { sendUndoAnnounce, sendVideoAnnounce } from './send'
 import { getLocalVideoAnnounceActivityPubUrl } from './url'
@@ -40,23 +40,7 @@ async function changeVideoChannelShare (
 async function addVideoShares (shareUrls: string[], video: MVideoId) {
  await Bluebird.map(shareUrls, async shareUrl => {
    try {
-      const { body } = await doJSONRequest<any>(shareUrl, { activityPub: true })
+      await addVideoShare(shareUrl, video)
-      if (!body || !body.actor) throw new Error('Body or body actor is invalid')
-      const actorUrl = getAPId(body.actor)
-      if (checkUrlsSameHost(shareUrl, actorUrl) !== true) {
-        throw new Error(`Actor url ${actorUrl} has not the same host than the share url ${shareUrl}`)
-      }
-      const actor = await getOrCreateActorAndServerAndModel(actorUrl)
-      const entry = {
-        actorId: actor.id,
-        videoId: video.id,
-        url: shareUrl
-      }
-      await VideoShareModel.upsert(entry)
    } catch (err) {
      logger.warn('Cannot add share %s.', shareUrl, { err })
    }
@@ -71,6 +55,26 @@ export {
 // ---------------------------------------------------------------------------
+async function addVideoShare (shareUrl: string, video: MVideoId) {
+  const { body } = await doJSONRequest<any>(shareUrl, { activityPub: true })
+  if (!body || !body.actor) throw new Error('Body or body actor is invalid')
+  const actorUrl = getAPId(body.actor)
+  if (checkUrlsSameHost(shareUrl, actorUrl) !== true) {
+    throw new Error(`Actor url ${actorUrl} has not the same host than the share url ${shareUrl}`)
+  }
+  const actor = await getOrCreateAPActor(actorUrl)
+  const entry = {
+    actorId: actor.id,
+    videoId: video.id,
+    url: shareUrl
+  }
+  await VideoShareModel.upsert(entry)
+}
 async function shareByServer (video: MVideo, t: Transaction) {
  const serverActor = await getServerActor()
diff --git a/server/lib/activitypub/video-comments.ts b/server/lib/activitypub/video-comments.ts
index e23e0c0e7..6b7f9504f 100644
--- a/server/lib/activitypub/video-comments.ts
+++ b/server/lib/activitypub/video-comments.ts
@@ -6,8 +6,8 @@ import { doJSONRequest } from '../../helpers/requests'
 import { ACTIVITY_PUB, CRAWL_REQUEST_CONCURRENCY } from '../../initializers/constants'
 import { VideoCommentModel } from '../../models/video/video-comment'
 import { MCommentOwner, MCommentOwnerVideo, MVideoAccountLightBlacklistAllFiles } from '../../types/models/video'
-import { getOrCreateActorAndServerAndModel } from './actor'
+import { getOrCreateAPActor } from './actors'
-import { getOrCreateVideoAndAccountAndChannel } from './videos'
+import { getOrCreateAPVideo } from './videos'
 type ResolveThreadParams = {
  url: string
@@ -29,10 +29,11 @@ async function addVideoComments (commentUrls: string[]) {
 async function resolveThread (params: ResolveThreadParams): ResolveThreadResult {
  const { url, isVideo } = params
  if (params.commentCreated === undefined) params.commentCreated = false
  if (params.comments === undefined) params.comments = []
-  // If it is not a video, or if we don't know if it's a video
+  // If it is not a video, or if we don't know if it's a video, try to get the thread from DB
  if (isVideo === false || isVideo === undefined) {
    const result = await resolveCommentFromDB(params)
    if (result) return result
@@ -42,7 +43,7 @@ async function resolveThread (params: ResolveThreadParams): ResolveThreadResult
    // If it is a video, or if we don't know if it's a video
    if (isVideo === true || isVideo === undefined) {
      // Keep await so we catch the exception
-      return await tryResolveThreadFromVideo(params)
+      return await tryToResolveThreadFromVideo(params)
    }
  } catch (err) {
    logger.debug('Cannot resolve thread from video %s, maybe because it was not a video', url, { err })
@@ -62,34 +63,32 @@ async function resolveCommentFromDB (params: ResolveThreadParams) {
  const { url, comments, commentCreated } = params
  const commentFromDatabase = await VideoCommentModel.loadByUrlAndPopulateReplyAndVideoUrlAndAccount(url)
-  if (commentFromDatabase) {
+  if (!commentFromDatabase) return undefined
-    let parentComments = comments.concat([ commentFromDatabase ])
-    // Speed up things and resolve directly the thread
+  let parentComments = comments.concat([ commentFromDatabase ])
-    if (commentFromDatabase.InReplyToVideoComment) {
-      const data = await VideoCommentModel.listThreadParentComments(commentFromDatabase, undefined, 'DESC')
-      parentComments = parentComments.concat(data)
+  // Speed up things and resolve directly the thread
-    }
+  if (commentFromDatabase.InReplyToVideoComment) {
+    const data = await VideoCommentModel.listThreadParentComments(commentFromDatabase, undefined, 'DESC')
-    return resolveThread({
+    parentComments = parentComments.concat(data)
-      url: commentFromDatabase.Video.url,
-      comments: parentComments,
-      isVideo: true,
-      commentCreated
-    })
  }
-  return undefined
+  return resolveThread({
+    url: commentFromDatabase.Video.url,
+    comments: parentComments,
+    isVideo: true,
+    commentCreated
+  })
 }
-async function tryResolveThreadFromVideo (params: ResolveThreadParams) {
+async function tryToResolveThreadFromVideo (params: ResolveThreadParams) {
  const { url, comments, commentCreated } = params
  // Maybe it's a reply to a video?
  // If yes, it's done: we resolved all the thread
  const syncParam = { likes: true, dislikes: true, shares: true, comments: false, thumbnail: true, refreshVideo: false }
-  const { video } = await getOrCreateVideoAndAccountAndChannel({ videoObject: url, syncParam })
+  const { video } = await getOrCreateAPVideo({ videoObject: url, syncParam })
  if (video.isOwned() && !video.hasPrivacyForFederation()) {
    throw new Error('Cannot resolve thread of video with privacy that is not compatible with federation')
@@ -148,7 +147,7 @@ async function resolveRemoteParentComment (params: ResolveThreadParams) {
  }
  const actor = actorUrl
-    ? await getOrCreateActorAndServerAndModel(actorUrl, 'all')
+    ? await getOrCreateAPActor(actorUrl, 'all')
    : null
  const comment = new VideoCommentModel({
diff --git a/server/lib/activitypub/video-rates.ts b/server/lib/activitypub/video-rates.ts
index f40c07fea..9fb97ef84 100644
--- a/server/lib/activitypub/video-rates.ts
+++ b/server/lib/activitypub/video-rates.ts
@@ -3,44 +3,23 @@ import { Transaction } from 'sequelize'
 import { doJSONRequest } from '@server/helpers/requests'
 import { VideoRateType } from '../../../shared/models/videos'
 import { checkUrlsSameHost, getAPId } from '../../helpers/activitypub'
-import { logger } from '../../helpers/logger'
+import { logger, loggerTagsFactory } from '../../helpers/logger'
 import { CRAWL_REQUEST_CONCURRENCY } from '../../initializers/constants'
 import { AccountVideoRateModel } from '../../models/account/account-video-rate'
 import { MAccountActor, MActorUrl, MVideo, MVideoAccountLight, MVideoId } from '../../types/models'
-import { getOrCreateActorAndServerAndModel } from './actor'
+import { getOrCreateAPActor } from './actors'
 import { sendLike, sendUndoDislike, sendUndoLike } from './send'
 import { sendDislike } from './send/send-dislike'
 import { getVideoDislikeActivityPubUrlByLocalActor, getVideoLikeActivityPubUrlByLocalActor } from './url'
+const lTags = loggerTagsFactory('ap', 'video-rate', 'create')
 async function createRates (ratesUrl: string[], video: MVideo, rate: VideoRateType) {
  await Bluebird.map(ratesUrl, async rateUrl => {
    try {
-      // Fetch url
+      await createRate(rateUrl, video, rate)
-      const { body } = await doJSONRequest<any>(rateUrl, { activityPub: true })
-      if (!body || !body.actor) throw new Error('Body or body actor is invalid')
-      const actorUrl = getAPId(body.actor)
-      if (checkUrlsSameHost(actorUrl, rateUrl) !== true) {
-        throw new Error(`Rate url ${rateUrl} has not the same host than actor url ${actorUrl}`)
-      }
-      if (checkUrlsSameHost(body.id, rateUrl) !== true) {
-        throw new Error(`Rate url ${rateUrl} host is different from the AP object id ${body.id}`)
-      }
-      const actor = await getOrCreateActorAndServerAndModel(actorUrl)
-      const entry = {
-        videoId: video.id,
-        accountId: actor.Account.id,
-        type: rate,
-        url: body.id
-      }
-      // Video "likes"/"dislikes" will be updated by the caller
-      await AccountVideoRateModel.upsert(entry)
    } catch (err) {
-      logger.warn('Cannot add rate %s.', rateUrl, { err })
+      logger.info('Cannot add rate %s.', rateUrl, { err, ...lTags(rateUrl, video.uuid, video.url) })
    }
  }, { concurrency: CRAWL_REQUEST_CONCURRENCY })
 }
@@ -73,8 +52,39 @@ function getLocalRateUrl (rateType: VideoRateType, actor: MActorUrl, video: MVid
    : getVideoDislikeActivityPubUrlByLocalActor(actor, video)
 }
+// ---------------------------------------------------------------------------
 export {
  getLocalRateUrl,
  createRates,
  sendVideoRateChange
 }
+// ---------------------------------------------------------------------------
+async function createRate (rateUrl: string, video: MVideo, rate: VideoRateType) {
+  // Fetch url
+  const { body } = await doJSONRequest<any>(rateUrl, { activityPub: true })
+  if (!body || !body.actor) throw new Error('Body or body actor is invalid')
+  const actorUrl = getAPId(body.actor)
+  if (checkUrlsSameHost(actorUrl, rateUrl) !== true) {
+    throw new Error(`Rate url ${rateUrl} has not the same host than actor url ${actorUrl}`)
+  }
+  if (checkUrlsSameHost(body.id, rateUrl) !== true) {
+    throw new Error(`Rate url ${rateUrl} host is different from the AP object id ${body.id}`)
+  }
+  const actor = await getOrCreateAPActor(actorUrl)
+  const entry = {
+    videoId: video.id,
+    accountId: actor.Account.id,
+    type: rate,
+    url: body.id
+  }
+  // Video "likes"/"dislikes" will be updated by the caller
+  await AccountVideoRateModel.upsert(entry)
+}
diff --git a/server/lib/activitypub/videos.ts b/server/lib/activitypub/videos.ts
deleted file mode 100644
index 127a0dd8a..000000000
--- a/server/lib/activitypub/videos.ts
+++ /dev/null
@@ -1,931 +0,0 @@
-import * as Bluebird from 'bluebird'
-import { maxBy, minBy } from 'lodash'
-import * as magnetUtil from 'magnet-uri'
-import { basename } from 'path'
-import { Transaction } from 'sequelize/types'
-import { TrackerModel } from '@server/models/server/tracker'
-import { VideoLiveModel } from '@server/models/video/video-live'
-import { HttpStatusCode } from '../../../shared/core-utils/miscs/http-error-codes'
-import {
-  ActivityHashTagObject,
-  ActivityMagnetUrlObject,
-  ActivityPlaylistSegmentHashesObject,
-  ActivityPlaylistUrlObject,
-  ActivitypubHttpFetcherPayload,
-  ActivityTagObject,
-  ActivityUrlObject,
-  ActivityVideoUrlObject
-} from '../../../shared/index'
-import { ActivityTrackerUrlObject, VideoObject } from '../../../shared/models/activitypub/objects'
-import { VideoPrivacy } from '../../../shared/models/videos'
-import { ThumbnailType } from '../../../shared/models/videos/thumbnail.type'
-import { VideoStreamingPlaylistType } from '../../../shared/models/videos/video-streaming-playlist.type'
-import { buildRemoteVideoBaseUrl, checkUrlsSameHost, getAPId } from '../../helpers/activitypub'
-import {
-  isAPVideoFileUrlMetadataObject,
-  isAPVideoTrackerUrlObject,
-  sanitizeAndCheckVideoTorrentObject
-} from '../../helpers/custom-validators/activitypub/videos'
-import { isArray } from '../../helpers/custom-validators/misc'
-import { isVideoFileInfoHashValid } from '../../helpers/custom-validators/videos'
-import { deleteNonExistingModels, resetSequelizeInstance, retryTransactionWrapper } from '../../helpers/database-utils'
-import { logger } from '../../helpers/logger'
-import { doJSONRequest, PeerTubeRequestError } from '../../helpers/requests'
-import { fetchVideoByUrl, getExtFromMimetype, VideoFetchByUrlType } from '../../helpers/video'
-import {
-  ACTIVITY_PUB,
-  MIMETYPES,
-  P2P_MEDIA_LOADER_PEER_VERSION,
-  PREVIEWS_SIZE,
-  REMOTE_SCHEME,
-  THUMBNAILS_SIZE
-} from '../../initializers/constants'
-import { sequelizeTypescript } from '../../initializers/database'
-import { AccountVideoRateModel } from '../../models/account/account-video-rate'
-import { VideoModel } from '../../models/video/video'
-import { VideoCaptionModel } from '../../models/video/video-caption'
-import { VideoCommentModel } from '../../models/video/video-comment'
-import { VideoFileModel } from '../../models/video/video-file'
-import { VideoShareModel } from '../../models/video/video-share'
-import { VideoStreamingPlaylistModel } from '../../models/video/video-streaming-playlist'
-import {
-  MAccountIdActor,
-  MChannelAccountLight,
-  MChannelDefault,
-  MChannelId,
-  MStreamingPlaylist,
-  MStreamingPlaylistFilesVideo,
-  MStreamingPlaylistVideo,
-  MVideo,
-  MVideoAccountLight,
-  MVideoAccountLightBlacklistAllFiles,
-  MVideoAP,
-  MVideoAPWithoutCaption,
-  MVideoCaption,
-  MVideoFile,
-  MVideoFullLight,
-  MVideoId,
-  MVideoImmutable,
-  MVideoThumbnail,
-  MVideoWithHost
-} from '../../types/models'
-import { MThumbnail } from '../../types/models/video/thumbnail'
-import { FilteredModelAttributes } from '../../types/sequelize'
-import { ActorFollowScoreCache } from '../files-cache'
-import { JobQueue } from '../job-queue'
-import { Notifier } from '../notifier'
-import { PeerTubeSocket } from '../peertube-socket'
-import { createPlaceholderThumbnail, createVideoMiniatureFromUrl } from '../thumbnail'
-import { setVideoTags } from '../video'
-import { autoBlacklistVideoIfNeeded } from '../video-blacklist'
-import { generateTorrentFileName } from '../video-paths'
-import { getOrCreateActorAndServerAndModel } from './actor'
-import { crawlCollectionPage } from './crawl'
-import { sendCreateVideo, sendUpdateVideo } from './send'
-import { addVideoShares, shareVideoByServerAndChannel } from './share'
-import { addVideoComments } from './video-comments'
-import { createRates } from './video-rates'
-async function federateVideoIfNeeded (videoArg: MVideoAPWithoutCaption, isNewVideo: boolean, transaction?: Transaction) {
-  const video = videoArg as MVideoAP
-  if (
-    // Check this is not a blacklisted video, or unfederated blacklisted video
-    (video.isBlacklisted() === false || (isNewVideo === false && video.VideoBlacklist.unfederated === false)) &&
-    // Check the video is public/unlisted and published
-    video.hasPrivacyForFederation() && video.hasStateForFederation()
-  ) {
-    // Fetch more attributes that we will need to serialize in AP object
-    if (isArray(video.VideoCaptions) === false) {
-      video.VideoCaptions = await video.$get('VideoCaptions', {
-        attributes: [ 'filename', 'language' ],
-        transaction
-      })
-    }
-    if (isNewVideo) {
-      // Now we'll add the video's meta data to our followers
-      await sendCreateVideo(video, transaction)
-      await shareVideoByServerAndChannel(video, transaction)
-    } else {
-      await sendUpdateVideo(video, transaction)
-    }
-  }
-}
-async function fetchRemoteVideo (videoUrl: string): Promise<{ statusCode: number, videoObject: VideoObject }> {
-  logger.info('Fetching remote video %s.', videoUrl)
-  const { statusCode, body } = await doJSONRequest<any>(videoUrl, { activityPub: true })
-  if (sanitizeAndCheckVideoTorrentObject(body) === false || checkUrlsSameHost(body.id, videoUrl) !== true) {
-    logger.debug('Remote video JSON is not valid.', { body })
-    return { statusCode, videoObject: undefined }
-  }
-  return { statusCode, videoObject: body }
-}
-async function fetchRemoteVideoDescription (video: MVideoAccountLight) {
-  const host = video.VideoChannel.Account.Actor.Server.host
-  const path = video.getDescriptionAPIPath()
-  const url = REMOTE_SCHEME.HTTP + '://' + host + path
-  const { body } = await doJSONRequest<any>(url)
-  return body.description || ''
-}
-function getOrCreateVideoChannelFromVideoObject (videoObject: VideoObject) {
-  const channel = videoObject.attributedTo.find(a => a.type === 'Group')
-  if (!channel) throw new Error('Cannot find associated video channel to video ' + videoObject.url)
-  if (checkUrlsSameHost(channel.id, videoObject.id) !== true) {
-    throw new Error(`Video channel url ${channel.id} does not have the same host than video object id ${videoObject.id}`)
-  }
-  return getOrCreateActorAndServerAndModel(channel.id, 'all')
-}
-type SyncParam = {
-  likes: boolean
-  dislikes: boolean
-  shares: boolean
-  comments: boolean
-  thumbnail: boolean
-  refreshVideo?: boolean
-}
-async function syncVideoExternalAttributes (video: MVideo, fetchedVideo: VideoObject, syncParam: SyncParam) {
-  logger.info('Adding likes/dislikes/shares/comments of video %s.', video.uuid)
-  const jobPayloads: ActivitypubHttpFetcherPayload[] = []
-  if (syncParam.likes === true) {
-    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, rootUrl: fetchedVideo.likes }))
-  } else {
-    jobPayloads.push({ uri: fetchedVideo.likes, videoId: video.id, type: 'video-likes' as 'video-likes' })
-  }
-  if (syncParam.dislikes === true) {
-    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, rootUrl: fetchedVideo.dislikes }))
-  } else {
-    jobPayloads.push({ uri: fetchedVideo.dislikes, videoId: video.id, type: 'video-dislikes' as 'video-dislikes' })
-  }
-  if (syncParam.shares === true) {
-    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, rootUrl: fetchedVideo.shares }))
-  } else {
-    jobPayloads.push({ uri: fetchedVideo.shares, videoId: video.id, type: 'video-shares' as 'video-shares' })
-  }
-  if (syncParam.comments === true) {
-    const handler = items => addVideoComments(items)
-    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, rootUrl: fetchedVideo.comments }))
-  } else {
-    jobPayloads.push({ uri: fetchedVideo.comments, videoId: video.id, type: 'video-comments' as 'video-comments' })
-  }
-  await Bluebird.map(jobPayloads, payload => JobQueue.Instance.createJobWithPromise({ type: 'activitypub-http-fetcher', payload }))
-}
-type GetVideoResult <T> = Promise<{
-  video: T
-  created: boolean
-  autoBlacklisted?: boolean
-}>
-type GetVideoParamAll = {
-  videoObject: { id: string } | string
-  syncParam?: SyncParam
-  fetchType?: 'all'
-  allowRefresh?: boolean
-}
-type GetVideoParamImmutable = {
-  videoObject: { id: string } | string
-  syncParam?: SyncParam
-  fetchType: 'only-immutable-attributes'
-  allowRefresh: false
-}
-type GetVideoParamOther = {
-  videoObject: { id: string } | string
-  syncParam?: SyncParam
-  fetchType?: 'all' | 'only-video'
-  allowRefresh?: boolean
-}
-function getOrCreateVideoAndAccountAndChannel (options: GetVideoParamAll): GetVideoResult<MVideoAccountLightBlacklistAllFiles>
-function getOrCreateVideoAndAccountAndChannel (options: GetVideoParamImmutable): GetVideoResult<MVideoImmutable>
-function getOrCreateVideoAndAccountAndChannel (
-  options: GetVideoParamOther
-): GetVideoResult<MVideoAccountLightBlacklistAllFiles | MVideoThumbnail>
-async function getOrCreateVideoAndAccountAndChannel (
-  options: GetVideoParamAll | GetVideoParamImmutable | GetVideoParamOther
-): GetVideoResult<MVideoAccountLightBlacklistAllFiles | MVideoThumbnail | MVideoImmutable> {
-  // Default params
-  const syncParam = options.syncParam || { likes: true, dislikes: true, shares: true, comments: true, thumbnail: true, refreshVideo: false }
-  const fetchType = options.fetchType || 'all'
-  const allowRefresh = options.allowRefresh !== false
-  // Get video url
-  const videoUrl = getAPId(options.videoObject)
-  let videoFromDatabase = await fetchVideoByUrl(videoUrl, fetchType)
-  if (videoFromDatabase) {
-    // If allowRefresh is true, we could not call this function using 'only-immutable-attributes' fetch type
-    if (allowRefresh === true && (videoFromDatabase as MVideoThumbnail).isOutdated()) {
-      const refreshOptions = {
-        video: videoFromDatabase as MVideoThumbnail,
-        fetchedType: fetchType,
-        syncParam
-      }
-      if (syncParam.refreshVideo === true) {
-        videoFromDatabase = await refreshVideoIfNeeded(refreshOptions)
-      } else {
-        await JobQueue.Instance.createJobWithPromise({
-          type: 'activitypub-refresher',
-          payload: { type: 'video', url: videoFromDatabase.url }
-        })
-      }
-    }
-    return { video: videoFromDatabase, created: false }
-  }
-  const { videoObject: fetchedVideo } = await fetchRemoteVideo(videoUrl)
-  if (!fetchedVideo) throw new Error('Cannot fetch remote video with url: ' + videoUrl)
-  const actor = await getOrCreateVideoChannelFromVideoObject(fetchedVideo)
-  const videoChannel = actor.VideoChannel
-  try {
-    const { autoBlacklisted, videoCreated } = await retryTransactionWrapper(createVideo, fetchedVideo, videoChannel, syncParam.thumbnail)
-    await syncVideoExternalAttributes(videoCreated, fetchedVideo, syncParam)
-    return { video: videoCreated, created: true, autoBlacklisted }
-  } catch (err) {
-    // Maybe a concurrent getOrCreateVideoAndAccountAndChannel call created this video
-    if (err.name === 'SequelizeUniqueConstraintError') {
-      const fallbackVideo = await fetchVideoByUrl(videoUrl, fetchType)
-      if (fallbackVideo) return { video: fallbackVideo, created: false }
-    }
-    throw err
-  }
-}
-async function updateVideoFromAP (options: {
-  video: MVideoAccountLightBlacklistAllFiles
-  videoObject: VideoObject
-  account: MAccountIdActor
-  channel: MChannelDefault
-  overrideTo?: string[]
-}) {
-  const { video, videoObject, account, channel, overrideTo } = options
-  logger.debug('Updating remote video "%s".', options.videoObject.uuid, { videoObject: options.videoObject, account, channel })
-  let videoFieldsSave: any
-  const wasPrivateVideo = video.privacy === VideoPrivacy.PRIVATE
-  const wasUnlistedVideo = video.privacy === VideoPrivacy.UNLISTED
-  try {
-    let thumbnailModel: MThumbnail
-    try {
-      thumbnailModel = await createVideoMiniatureFromUrl({
-        downloadUrl: getThumbnailFromIcons(videoObject).url,
-        video,
-        type: ThumbnailType.MINIATURE
-      })
-    } catch (err) {
-      logger.warn('Cannot generate thumbnail of %s.', videoObject.id, { err })
-    }
-    const videoUpdated = await sequelizeTypescript.transaction(async t => {
-      const sequelizeOptions = { transaction: t }
-      videoFieldsSave = video.toJSON()
-      // Check we can update the channel: we trust the remote server
-      const oldVideoChannel = video.VideoChannel
-      if (!oldVideoChannel.Actor.serverId || !channel.Actor.serverId) {
-        throw new Error('Cannot check old channel/new channel validity because `serverId` is null')
-      }
-      if (oldVideoChannel.Actor.serverId !== channel.Actor.serverId) {
-        throw new Error('New channel ' + channel.Actor.url + ' is not on the same server than new channel ' + oldVideoChannel.Actor.url)
-      }
-      const to = overrideTo || videoObject.to
-      const videoData = videoActivityObjectToDBAttributes(channel, videoObject, to)
-      video.name = videoData.name
-      video.uuid = videoData.uuid
-      video.url = videoData.url
-      video.category = videoData.category
-      video.licence = videoData.licence
-      video.language = videoData.language
-      video.description = videoData.description
-      video.support = videoData.support
-      video.nsfw = videoData.nsfw
-      video.commentsEnabled = videoData.commentsEnabled
-      video.downloadEnabled = videoData.downloadEnabled
-      video.waitTranscoding = videoData.waitTranscoding
-      video.state = videoData.state
-      video.duration = videoData.duration
-      video.createdAt = videoData.createdAt
-      video.publishedAt = videoData.publishedAt
-      video.originallyPublishedAt = videoData.originallyPublishedAt
-      video.privacy = videoData.privacy
-      video.channelId = videoData.channelId
-      video.views = videoData.views
-      video.isLive = videoData.isLive
-      // Ensures we update the updated video attribute
-      video.changed('updatedAt', true)
-      const videoUpdated = await video.save(sequelizeOptions) as MVideoFullLight
-      if (thumbnailModel) await videoUpdated.addAndSaveThumbnail(thumbnailModel, t)
-      const previewIcon = getPreviewFromIcons(videoObject)
-      if (videoUpdated.getPreview() && previewIcon) {
-        const previewModel = createPlaceholderThumbnail({
-          fileUrl: previewIcon.url,
-          video,
-          type: ThumbnailType.PREVIEW,
-          size: previewIcon
-        })
-        await videoUpdated.addAndSaveThumbnail(previewModel, t)
-      }
-      {
-        const videoFileAttributes = videoFileActivityUrlToDBAttributes(videoUpdated, videoObject.url)
-        const newVideoFiles = videoFileAttributes.map(a => new VideoFileModel(a))
-        // Remove video files that do not exist anymore
-        const destroyTasks = deleteNonExistingModels(videoUpdated.VideoFiles, newVideoFiles, t)
-        await Promise.all(destroyTasks)
-        // Update or add other one
-        const upsertTasks = newVideoFiles.map(f => VideoFileModel.customUpsert(f, 'video', t))
-        videoUpdated.VideoFiles = await Promise.all(upsertTasks)
-      }
-      {
-        const streamingPlaylistAttributes = streamingPlaylistActivityUrlToDBAttributes(videoUpdated, videoObject, videoUpdated.VideoFiles)
-        const newStreamingPlaylists = streamingPlaylistAttributes.map(a => new VideoStreamingPlaylistModel(a))
-        // Remove video playlists that do not exist anymore
-        const destroyTasks = deleteNonExistingModels(videoUpdated.VideoStreamingPlaylists, newStreamingPlaylists, t)
-        await Promise.all(destroyTasks)
-        let oldStreamingPlaylistFiles: MVideoFile[] = []
-        for (const videoStreamingPlaylist of videoUpdated.VideoStreamingPlaylists) {
-          oldStreamingPlaylistFiles = oldStreamingPlaylistFiles.concat(videoStreamingPlaylist.VideoFiles)
-        }
-        videoUpdated.VideoStreamingPlaylists = []
-        for (const playlistAttributes of streamingPlaylistAttributes) {
-          const streamingPlaylistModel = await VideoStreamingPlaylistModel.upsert(playlistAttributes, { returning: true, transaction: t })
-                                     .then(([ streamingPlaylist ]) => streamingPlaylist as MStreamingPlaylistFilesVideo)
-          streamingPlaylistModel.Video = videoUpdated
-          const newVideoFiles: MVideoFile[] = videoFileActivityUrlToDBAttributes(streamingPlaylistModel, playlistAttributes.tagAPObject)
-            .map(a => new VideoFileModel(a))
-          const destroyTasks = deleteNonExistingModels(oldStreamingPlaylistFiles, newVideoFiles, t)
-          await Promise.all(destroyTasks)
-          // Update or add other one
-          const upsertTasks = newVideoFiles.map(f => VideoFileModel.customUpsert(f, 'streaming-playlist', t))
-          streamingPlaylistModel.VideoFiles = await Promise.all(upsertTasks)
-          videoUpdated.VideoStreamingPlaylists.push(streamingPlaylistModel)
-        }
-      }
-      {
-        // Update Tags
-        const tags = videoObject.tag
-                                .filter(isAPHashTagObject)
-                                .map(tag => tag.name)
-        await setVideoTags({ video: videoUpdated, tags, transaction: t })
-      }
-      // Update trackers
-      {
-        const trackers = getTrackerUrls(videoObject, videoUpdated)
-        await setVideoTrackers({ video: videoUpdated, trackers, transaction: t })
-      }
-      {
-        // Update captions
-        await VideoCaptionModel.deleteAllCaptionsOfRemoteVideo(videoUpdated.id, t)
-        const videoCaptionsPromises = videoObject.subtitleLanguage.map(c => {
-          const caption = new VideoCaptionModel({
-            videoId: videoUpdated.id,
-            filename: VideoCaptionModel.generateCaptionName(c.identifier),
-            language: c.identifier,
-            fileUrl: c.url
-          }) as MVideoCaption
-          return VideoCaptionModel.insertOrReplaceLanguage(caption, t)
-        })
-        await Promise.all(videoCaptionsPromises)
-      }
-      {
-        // Create or update existing live
-        if (video.isLive) {
-          const [ videoLive ] = await VideoLiveModel.upsert({
-            saveReplay: videoObject.liveSaveReplay,
-            permanentLive: videoObject.permanentLive,
-            videoId: video.id
-          }, { transaction: t, returning: true })
-          videoUpdated.VideoLive = videoLive
-        } else { // Delete existing live if it exists
-          await VideoLiveModel.destroy({
-            where: {
-              videoId: video.id
-            },
-            transaction: t
-          })
-          videoUpdated.VideoLive = null
-        }
-      }
-      return videoUpdated
-    })
-    await autoBlacklistVideoIfNeeded({
-      video: videoUpdated,
-      user: undefined,
-      isRemote: true,
-      isNew: false,
-      transaction: undefined
-    })
-    // Notify our users?
-    if (wasPrivateVideo || wasUnlistedVideo) Notifier.Instance.notifyOnNewVideoIfNeeded(videoUpdated)
-    if (videoUpdated.isLive) {
-      PeerTubeSocket.Instance.sendVideoLiveNewState(videoUpdated)
-      PeerTubeSocket.Instance.sendVideoViewsUpdate(videoUpdated)
-    }
-    logger.info('Remote video with uuid %s updated', videoObject.uuid)
-    return videoUpdated
-  } catch (err) {
-    if (video !== undefined && videoFieldsSave !== undefined) {
-      resetSequelizeInstance(video, videoFieldsSave)
-    }
-    // This is just a debug because we will retry the insert
-    logger.debug('Cannot update the remote video.', { err })
-    throw err
-  }
-}
-async function refreshVideoIfNeeded (options: {
-  video: MVideoThumbnail
-  fetchedType: VideoFetchByUrlType
-  syncParam: SyncParam
-}): Promise<MVideoThumbnail> {
-  if (!options.video.isOutdated()) return options.video
-  // We need more attributes if the argument video was fetched with not enough joints
-  const video = options.fetchedType === 'all'
-    ? options.video as MVideoAccountLightBlacklistAllFiles
-    : await VideoModel.loadByUrlAndPopulateAccount(options.video.url)
-  try {
-    const { videoObject } = await fetchRemoteVideo(video.url)
-    if (videoObject === undefined) {
-      logger.warn('Cannot refresh remote video %s: invalid body.', video.url)
-      await video.setAsRefreshed()
-      return video
-    }
-    const channelActor = await getOrCreateVideoChannelFromVideoObject(videoObject)
-    const updateOptions = {
-      video,
-      videoObject,
-      account: channelActor.VideoChannel.Account,
-      channel: channelActor.VideoChannel
-    }
-    await updateVideoFromAP(updateOptions)
-    await syncVideoExternalAttributes(video, videoObject, options.syncParam)
-    ActorFollowScoreCache.Instance.addGoodServerId(video.VideoChannel.Actor.serverId)
-    return video
-  } catch (err) {
-    if ((err as PeerTubeRequestError).statusCode === HttpStatusCode.NOT_FOUND_404) {
-      logger.info('Cannot refresh remote video %s: video does not exist anymore. Deleting it.', video.url)
-      // Video does not exist anymore
-      await video.destroy()
-      return undefined
-    }
-    logger.warn('Cannot refresh video %s.', options.video.url, { err })
-    ActorFollowScoreCache.Instance.addBadServerId(video.VideoChannel.Actor.serverId)
-    // Don't refresh in loop
-    await video.setAsRefreshed()
-    return video
-  }
-}
-export {
-  updateVideoFromAP,
-  refreshVideoIfNeeded,
-  federateVideoIfNeeded,
-  fetchRemoteVideo,
-  getOrCreateVideoAndAccountAndChannel,
-  fetchRemoteVideoDescription,
-  getOrCreateVideoChannelFromVideoObject
-}
-// ---------------------------------------------------------------------------
-function isAPVideoUrlObject (url: any): url is ActivityVideoUrlObject {
-  const urlMediaType = url.mediaType
-  return MIMETYPES.VIDEO.MIMETYPE_EXT[urlMediaType] && urlMediaType.startsWith('video/')
-}
-function isAPStreamingPlaylistUrlObject (url: any): url is ActivityPlaylistUrlObject {
-  return url && url.mediaType === 'application/x-mpegURL'
-}
-function isAPPlaylistSegmentHashesUrlObject (tag: any): tag is ActivityPlaylistSegmentHashesObject {
-  return tag && tag.name === 'sha256' && tag.type === 'Link' && tag.mediaType === 'application/json'
-}
-function isAPMagnetUrlObject (url: any): url is ActivityMagnetUrlObject {
-  return url && url.mediaType === 'application/x-bittorrent;x-scheme-handler/magnet'
-}
-function isAPHashTagObject (url: any): url is ActivityHashTagObject {
-  return url && url.type === 'Hashtag'
-}
-async function createVideo (videoObject: VideoObject, channel: MChannelAccountLight, waitThumbnail = false) {
-  logger.debug('Adding remote video %s.', videoObject.id)
-  const videoData = await videoActivityObjectToDBAttributes(channel, videoObject, videoObject.to)
-  const video = VideoModel.build(videoData) as MVideoThumbnail
-  const promiseThumbnail = createVideoMiniatureFromUrl({
-    downloadUrl: getThumbnailFromIcons(videoObject).url,
-    video,
-    type: ThumbnailType.MINIATURE
-  }).catch(err => {
-    logger.error('Cannot create miniature from url.', { err })
-    return undefined
-  })
-  let thumbnailModel: MThumbnail
-  if (waitThumbnail === true) {
-    thumbnailModel = await promiseThumbnail
-  }
-  const { autoBlacklisted, videoCreated } = await sequelizeTypescript.transaction(async t => {
-    try {
-      const sequelizeOptions = { transaction: t }
-      const videoCreated = await video.save(sequelizeOptions) as MVideoFullLight
-      videoCreated.VideoChannel = channel
-      if (thumbnailModel) await videoCreated.addAndSaveThumbnail(thumbnailModel, t)
-      const previewIcon = getPreviewFromIcons(videoObject)
-      if (previewIcon) {
-        const previewModel = createPlaceholderThumbnail({
-          fileUrl: previewIcon.url,
-          video: videoCreated,
-          type: ThumbnailType.PREVIEW,
-          size: previewIcon
-        })
-        await videoCreated.addAndSaveThumbnail(previewModel, t)
-      }
-      // Process files
-      const videoFileAttributes = videoFileActivityUrlToDBAttributes(videoCreated, videoObject.url)
-      const videoFilePromises = videoFileAttributes.map(f => VideoFileModel.create(f, { transaction: t }))
-      const videoFiles = await Promise.all(videoFilePromises)
-      const streamingPlaylistsAttributes = streamingPlaylistActivityUrlToDBAttributes(videoCreated, videoObject, videoFiles)
-      videoCreated.VideoStreamingPlaylists = []
-      for (const playlistAttributes of streamingPlaylistsAttributes) {
-        const playlist = await VideoStreamingPlaylistModel.create(playlistAttributes, { transaction: t }) as MStreamingPlaylistFilesVideo
-        playlist.Video = videoCreated
-        const playlistFiles = videoFileActivityUrlToDBAttributes(playlist, playlistAttributes.tagAPObject)
-        const videoFilePromises = playlistFiles.map(f => VideoFileModel.create(f, { transaction: t }))
-        playlist.VideoFiles = await Promise.all(videoFilePromises)
-        videoCreated.VideoStreamingPlaylists.push(playlist)
-      }
-      // Process tags
-      const tags = videoObject.tag
-                              .filter(isAPHashTagObject)
-                              .map(t => t.name)
-      await setVideoTags({ video: videoCreated, tags, transaction: t })
-      // Process captions
-      const videoCaptionsPromises = videoObject.subtitleLanguage.map(c => {
-        const caption = new VideoCaptionModel({
-          videoId: videoCreated.id,
-          filename: VideoCaptionModel.generateCaptionName(c.identifier),
-          language: c.identifier,
-          fileUrl: c.url
-        }) as MVideoCaption
-        return VideoCaptionModel.insertOrReplaceLanguage(caption, t)
-      })
-      await Promise.all(videoCaptionsPromises)
-      // Process trackers
-      {
-        const trackers = getTrackerUrls(videoObject, videoCreated)
-        await setVideoTrackers({ video: videoCreated, trackers, transaction: t })
-      }
-      videoCreated.VideoFiles = videoFiles
-      if (videoCreated.isLive) {
-        const videoLive = new VideoLiveModel({
-          streamKey: null,
-          saveReplay: videoObject.liveSaveReplay,
-          permanentLive: videoObject.permanentLive,
-          videoId: videoCreated.id
-        })
-        videoCreated.VideoLive = await videoLive.save({ transaction: t })
-      }
-      // We added a video in this channel, set it as updated
-      await channel.setAsUpdated(t)
-      const autoBlacklisted = await autoBlacklistVideoIfNeeded({
-        video: videoCreated,
-        user: undefined,
-        isRemote: true,
-        isNew: true,
-        transaction: t
-      })
-      logger.info('Remote video with uuid %s inserted.', videoObject.uuid)
-      return { autoBlacklisted, videoCreated }
-    } catch (err) {
-      // FIXME: Use rollback hook when https://github.com/sequelize/sequelize/pull/13038 is released
-      // Remove thumbnail
-      if (thumbnailModel) await thumbnailModel.removeThumbnail()
-      throw err
-    }
-  })
-  if (waitThumbnail === false) {
-    // Error is already caught above
-    // eslint-disable-next-line @typescript-eslint/no-floating-promises
-    promiseThumbnail.then(thumbnailModel => {
-      if (!thumbnailModel) return
-      thumbnailModel = videoCreated.id
-      return thumbnailModel.save()
-    })
-  }
-  return { autoBlacklisted, videoCreated }
-}
-function videoActivityObjectToDBAttributes (videoChannel: MChannelId, videoObject: VideoObject, to: string[] = []) {
-  const privacy = to.includes(ACTIVITY_PUB.PUBLIC)
-    ? VideoPrivacy.PUBLIC
-    : VideoPrivacy.UNLISTED
-  const duration = videoObject.duration.replace(/[^\d]+/, '')
-  const language = videoObject.language?.identifier
-  const category = videoObject.category
-    ? parseInt(videoObject.category.identifier, 10)
-    : undefined
-  const licence = videoObject.licence
-    ? parseInt(videoObject.licence.identifier, 10)
-    : undefined
-  const description = videoObject.content || null
-  const support = videoObject.support || null
-  return {
-    name: videoObject.name,
-    uuid: videoObject.uuid,
-    url: videoObject.id,
-    category,
-    licence,
-    language,
-    description,
-    support,
-    nsfw: videoObject.sensitive,
-    commentsEnabled: videoObject.commentsEnabled,
-    downloadEnabled: videoObject.downloadEnabled,
-    waitTranscoding: videoObject.waitTranscoding,
-    isLive: videoObject.isLiveBroadcast,
-    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,
-    updatedAt: new Date(videoObject.updated),
-    views: videoObject.views,
-    likes: 0,
-    dislikes: 0,
-    remote: true,
-    privacy
-  }
-}
-function videoFileActivityUrlToDBAttributes (
-  videoOrPlaylist: MVideo | MStreamingPlaylistVideo,
-  urls: (ActivityTagObject | ActivityUrlObject)[]
-) {
-  const fileUrls = urls.filter(u => isAPVideoUrlObject(u)) as ActivityVideoUrlObject[]
-  if (fileUrls.length === 0) return []
-  const attributes: FilteredModelAttributes<VideoFileModel>[] = []
-  for (const fileUrl of fileUrls) {
-    // Fetch associated magnet uri
-    const magnet = urls.filter(isAPMagnetUrlObject)
-                       .find(u => u.height === fileUrl.height)
-    if (!magnet) throw new Error('Cannot find associated magnet uri for file ' + fileUrl.href)
-    const parsed = magnetUtil.decode(magnet.href)
-    if (!parsed || isVideoFileInfoHashValid(parsed.infoHash) === false) {
-      throw new Error('Cannot parse magnet URI ' + magnet.href)
-    }
-    const torrentUrl = Array.isArray(parsed.xs)
-      ? parsed.xs[0]
-      : parsed.xs
-    // Fetch associated metadata url, if any
-    const metadata = urls.filter(isAPVideoFileUrlMetadataObject)
-                         .find(u => {
-                           return u.height === fileUrl.height &&
-                             u.fps === fileUrl.fps &&
-                             u.rel.includes(fileUrl.mediaType)
-                         })
-    const extname = getExtFromMimetype(MIMETYPES.VIDEO.MIMETYPE_EXT, fileUrl.mediaType)
-    const resolution = fileUrl.height
-    const videoId = (videoOrPlaylist as MStreamingPlaylist).playlistUrl ? null : videoOrPlaylist.id
-    const videoStreamingPlaylistId = (videoOrPlaylist as MStreamingPlaylist).playlistUrl ? videoOrPlaylist.id : null
-    const attribute = {
-      extname,
-      infoHash: parsed.infoHash,
-      resolution,
-      size: fileUrl.size,
-      fps: fileUrl.fps || -1,
-      metadataUrl: metadata?.href,
-      // Use the name of the remote file because we don't proxify video file requests
-      filename: basename(fileUrl.href),
-      fileUrl: fileUrl.href,
-      torrentUrl,
-      // Use our own torrent name since we proxify torrent requests
-      torrentFilename: generateTorrentFileName(videoOrPlaylist, resolution),
-      // This is a video file owned by a video or by a streaming playlist
-      videoId,
-      videoStreamingPlaylistId
-    }
-    attributes.push(attribute)
-  }
-  return attributes
-}
-function streamingPlaylistActivityUrlToDBAttributes (video: MVideoId, videoObject: VideoObject, videoFiles: MVideoFile[]) {
-  const playlistUrls = videoObject.url.filter(u => isAPStreamingPlaylistUrlObject(u)) as ActivityPlaylistUrlObject[]
-  if (playlistUrls.length === 0) return []
-  const attributes: (FilteredModelAttributes<VideoStreamingPlaylistModel> & { tagAPObject?: ActivityTagObject[] })[] = []
-  for (const playlistUrlObject of playlistUrls) {
-    const segmentsSha256UrlObject = playlistUrlObject.tag.find(isAPPlaylistSegmentHashesUrlObject)
-    let files: unknown[] = playlistUrlObject.tag.filter(u => isAPVideoUrlObject(u)) as ActivityVideoUrlObject[]
-    // FIXME: backward compatibility introduced in v2.1.0
-    if (files.length === 0) files = videoFiles
-    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, files),
-      p2pMediaLoaderPeerVersion: P2P_MEDIA_LOADER_PEER_VERSION,
-      videoId: video.id,
-      tagAPObject: playlistUrlObject.tag
-    }
-    attributes.push(attribute)
-  }
-  return attributes
-}
-function getThumbnailFromIcons (videoObject: VideoObject) {
-  let validIcons = videoObject.icon.filter(i => i.width > THUMBNAILS_SIZE.minWidth)
-  // Fallback if there are not valid icons
-  if (validIcons.length === 0) validIcons = videoObject.icon
-  return minBy(validIcons, 'width')
-}
-function getPreviewFromIcons (videoObject: VideoObject) {
-  const validIcons = videoObject.icon.filter(i => i.width > PREVIEWS_SIZE.minWidth)
-  return maxBy(validIcons, 'width')
-}
-function getTrackerUrls (object: VideoObject, video: MVideoWithHost) {
-  let wsFound = false
-  const trackers = object.url.filter(u => isAPVideoTrackerUrlObject(u))
-    .map((u: ActivityTrackerUrlObject) => {
-      if (isArray(u.rel) && u.rel.includes('websocket')) wsFound = true
-      return u.href
-    })
-  if (wsFound) return trackers
-  return [
-    buildRemoteVideoBaseUrl(video, '/tracker/socket', REMOTE_SCHEME.WS),
-    buildRemoteVideoBaseUrl(video, '/tracker/announce')
-  ]
-}
-async function setVideoTrackers (options: {
-  video: MVideo
-  trackers: string[]
-  transaction?: Transaction
-}) {
-  const { video, trackers, transaction } = options
-  const trackerInstances = await TrackerModel.findOrCreateTrackers(trackers, transaction)
-  await video.$set('Trackers', trackerInstances, { transaction })
-}
diff --git a/server/lib/activitypub/videos/federate.ts b/server/lib/activitypub/videos/federate.ts
new file mode 100644
index 000000000..bd0c54b0c
--- /dev/null
+++ b/server/lib/activitypub/videos/federate.ts
@@ -0,0 +1,36 @@
+import { Transaction } from 'sequelize/types'
+import { isArray } from '@server/helpers/custom-validators/misc'
+import { MVideoAP, MVideoAPWithoutCaption } from '@server/types/models'
+import { sendCreateVideo, sendUpdateVideo } from '../send'
+import { shareVideoByServerAndChannel } from '../share'
+async function federateVideoIfNeeded (videoArg: MVideoAPWithoutCaption, isNewVideo: boolean, transaction?: Transaction) {
+  const video = videoArg as MVideoAP
+  if (
+    // Check this is not a blacklisted video, or unfederated blacklisted video
+    (video.isBlacklisted() === false || (isNewVideo === false && video.VideoBlacklist.unfederated === false)) &&
+    // Check the video is public/unlisted and published
+    video.hasPrivacyForFederation() && video.hasStateForFederation()
+  ) {
+    // Fetch more attributes that we will need to serialize in AP object
+    if (isArray(video.VideoCaptions) === false) {
+      video.VideoCaptions = await video.$get('VideoCaptions', {
+        attributes: [ 'filename', 'language' ],
+        transaction
+      })
+    }
+    if (isNewVideo) {
+      // Now we'll add the video's meta data to our followers
+      await sendCreateVideo(video, transaction)
+      await shareVideoByServerAndChannel(video, transaction)
+    } else {
+      await sendUpdateVideo(video, transaction)
+    }
+  }
+}
+export {
+  federateVideoIfNeeded
+}
diff --git a/server/lib/activitypub/videos/get.ts b/server/lib/activitypub/videos/get.ts
new file mode 100644
index 000000000..f3e2f0625
--- /dev/null
+++ b/server/lib/activitypub/videos/get.ts
@@ -0,0 +1,113 @@
+import { getAPId } from '@server/helpers/activitypub'
+import { retryTransactionWrapper } from '@server/helpers/database-utils'
+import { JobQueue } from '@server/lib/job-queue'
+import { loadVideoByUrl, VideoLoadByUrlType } from '@server/lib/model-loaders'
+import { MVideoAccountLightBlacklistAllFiles, MVideoImmutable, MVideoThumbnail } from '@server/types/models'
+import { APObject } from '@shared/models'
+import { refreshVideoIfNeeded } from './refresh'
+import { APVideoCreator, fetchRemoteVideo, SyncParam, syncVideoExternalAttributes } from './shared'
+type GetVideoResult <T> = Promise<{
+  video: T
+  created: boolean
+  autoBlacklisted?: boolean
+}>
+type GetVideoParamAll = {
+  videoObject: APObject
+  syncParam?: SyncParam
+  fetchType?: 'all'
+  allowRefresh?: boolean
+}
+type GetVideoParamImmutable = {
+  videoObject: APObject
+  syncParam?: SyncParam
+  fetchType: 'only-immutable-attributes'
+  allowRefresh: false
+}
+type GetVideoParamOther = {
+  videoObject: APObject
+  syncParam?: SyncParam
+  fetchType?: 'all' | 'only-video'
+  allowRefresh?: boolean
+}
+function getOrCreateAPVideo (options: GetVideoParamAll): GetVideoResult<MVideoAccountLightBlacklistAllFiles>
+function getOrCreateAPVideo (options: GetVideoParamImmutable): GetVideoResult<MVideoImmutable>
+function getOrCreateAPVideo (options: GetVideoParamOther): GetVideoResult<MVideoAccountLightBlacklistAllFiles | MVideoThumbnail>
+async function getOrCreateAPVideo (
+  options: GetVideoParamAll | GetVideoParamImmutable | GetVideoParamOther
+): GetVideoResult<MVideoAccountLightBlacklistAllFiles | MVideoThumbnail | MVideoImmutable> {
+  // Default params
+  const syncParam = options.syncParam || { likes: true, dislikes: true, shares: true, comments: true, thumbnail: true, refreshVideo: false }
+  const fetchType = options.fetchType || 'all'
+  const allowRefresh = options.allowRefresh !== false
+  // Get video url
+  const videoUrl = getAPId(options.videoObject)
+  let videoFromDatabase = await loadVideoByUrl(videoUrl, fetchType)
+  if (videoFromDatabase) {
+    if (allowRefresh === true) {
+      // Typings ensure allowRefresh === false in only-immutable-attributes fetch type
+      videoFromDatabase = await scheduleRefresh(videoFromDatabase as MVideoThumbnail, fetchType, syncParam)
+    }
+    return { video: videoFromDatabase, created: false }
+  }
+  const { videoObject } = await fetchRemoteVideo(videoUrl)
+  if (!videoObject) throw new Error('Cannot fetch remote video with url: ' + videoUrl)
+  // videoUrl is just an alias/rediraction, so process object id instead
+  if (videoObject.id !== videoUrl) return getOrCreateAPVideo({ ...options, fetchType: 'all', videoObject })
+  try {
+    const creator = new APVideoCreator(videoObject)
+    const { autoBlacklisted, videoCreated } = await retryTransactionWrapper(creator.create.bind(creator), syncParam.thumbnail)
+    await syncVideoExternalAttributes(videoCreated, videoObject, syncParam)
+    return { video: videoCreated, created: true, autoBlacklisted }
+  } catch (err) {
+    // Maybe a concurrent getOrCreateAPVideo call created this video
+    if (err.name === 'SequelizeUniqueConstraintError') {
+      const alreadyCreatedVideo = await loadVideoByUrl(videoUrl, fetchType)
+      if (alreadyCreatedVideo) return { video: alreadyCreatedVideo, created: false }
+    }
+    throw err
+  }
+}
+// ---------------------------------------------------------------------------
+export {
+  getOrCreateAPVideo
+}
+// ---------------------------------------------------------------------------
+async function scheduleRefresh (video: MVideoThumbnail, fetchType: VideoLoadByUrlType, syncParam: SyncParam) {
+  if (!video.isOutdated()) return video
+  const refreshOptions = {
+    video,
+    fetchedType: fetchType,
+    syncParam
+  }
+  if (syncParam.refreshVideo === true) {
+    return refreshVideoIfNeeded(refreshOptions)
+  }
+  await JobQueue.Instance.createJobWithPromise({
+    type: 'activitypub-refresher',
+    payload: { type: 'video', url: video.url }
+  })
+  return video
+}
diff --git a/server/lib/activitypub/videos/index.ts b/server/lib/activitypub/videos/index.ts
new file mode 100644
index 000000000..b22062598
--- /dev/null
+++ b/server/lib/activitypub/videos/index.ts
@@ -0,0 +1,4 @@
+export * from './federate'
+export * from './get'
+export * from './refresh'
+export * from './updater'
diff --git a/server/lib/activitypub/videos/refresh.ts b/server/lib/activitypub/videos/refresh.ts
new file mode 100644
index 000000000..a7b82f286
--- /dev/null
+++ b/server/lib/activitypub/videos/refresh.ts
@@ -0,0 +1,68 @@
+import { logger, loggerTagsFactory } from '@server/helpers/logger'
+import { PeerTubeRequestError } from '@server/helpers/requests'
+import { ActorFollowScoreCache } from '@server/lib/files-cache'
+import { VideoLoadByUrlType } from '@server/lib/model-loaders'
+import { VideoModel } from '@server/models/video/video'
+import { MVideoAccountLightBlacklistAllFiles, MVideoThumbnail } from '@server/types/models'
+import { HttpStatusCode } from '@shared/core-utils'
+import { fetchRemoteVideo, SyncParam, syncVideoExternalAttributes } from './shared'
+import { APVideoUpdater } from './updater'
+async function refreshVideoIfNeeded (options: {
+  video: MVideoThumbnail
+  fetchedType: VideoLoadByUrlType
+  syncParam: SyncParam
+}): Promise<MVideoThumbnail> {
+  if (!options.video.isOutdated()) return options.video
+  // We need more attributes if the argument video was fetched with not enough joints
+  const video = options.fetchedType === 'all'
+    ? options.video as MVideoAccountLightBlacklistAllFiles
+    : await VideoModel.loadByUrlAndPopulateAccount(options.video.url)
+  const lTags = loggerTagsFactory('ap', 'video', 'refresh', video.uuid, video.url)
+  logger.info('Refreshing video %s.', video.url, lTags())
+  try {
+    const { videoObject } = await fetchRemoteVideo(video.url)
+    if (videoObject === undefined) {
+      logger.warn('Cannot refresh remote video %s: invalid body.', video.url, lTags())
+      await video.setAsRefreshed()
+      return video
+    }
+    const videoUpdater = new APVideoUpdater(videoObject, video)
+    await videoUpdater.update()
+    await syncVideoExternalAttributes(video, videoObject, options.syncParam)
+    ActorFollowScoreCache.Instance.addGoodServerId(video.VideoChannel.Actor.serverId)
+    return video
+  } catch (err) {
+    if ((err as PeerTubeRequestError).statusCode === HttpStatusCode.NOT_FOUND_404) {
+      logger.info('Cannot refresh remote video %s: video does not exist anymore. Deleting it.', video.url, lTags())
+      // Video does not exist anymore
+      await video.destroy()
+      return undefined
+    }
+    logger.warn('Cannot refresh video %s.', options.video.url, { err, ...lTags() })
+    ActorFollowScoreCache.Instance.addBadServerId(video.VideoChannel.Actor.serverId)
+    // Don't refresh in loop
+    await video.setAsRefreshed()
+    return video
+  }
+}
+// ---------------------------------------------------------------------------
+export {
+  refreshVideoIfNeeded
+}
diff --git a/server/lib/activitypub/videos/shared/abstract-builder.ts b/server/lib/activitypub/videos/shared/abstract-builder.ts
new file mode 100644
index 000000000..e89c94bcd
--- /dev/null
+++ b/server/lib/activitypub/videos/shared/abstract-builder.ts
@@ -0,0 +1,173 @@
+import { Transaction } from 'sequelize/types'
+import { checkUrlsSameHost } from '@server/helpers/activitypub'
+import { deleteNonExistingModels } from '@server/helpers/database-utils'
+import { logger, LoggerTagsFn } from '@server/helpers/logger'
+import { updatePlaceholderThumbnail, updateVideoMiniatureFromUrl } from '@server/lib/thumbnail'
+import { setVideoTags } from '@server/lib/video'
+import { VideoCaptionModel } from '@server/models/video/video-caption'
+import { VideoFileModel } from '@server/models/video/video-file'
+import { VideoLiveModel } from '@server/models/video/video-live'
+import { VideoStreamingPlaylistModel } from '@server/models/video/video-streaming-playlist'
+import { MStreamingPlaylistFilesVideo, MThumbnail, MVideoCaption, MVideoFile, MVideoFullLight, MVideoThumbnail } from '@server/types/models'
+import { ActivityTagObject, ThumbnailType, VideoObject, VideoStreamingPlaylistType } from '@shared/models'
+import { getOrCreateAPActor } from '../../actors'
+import {
+  getCaptionAttributesFromObject,
+  getFileAttributesFromUrl,
+  getLiveAttributesFromObject,
+  getPreviewFromIcons,
+  getStreamingPlaylistAttributesFromObject,
+  getTagsFromObject,
+  getThumbnailFromIcons
+} from './object-to-model-attributes'
+import { getTrackerUrls, setVideoTrackers } from './trackers'
+export abstract class APVideoAbstractBuilder {
+  protected abstract videoObject: VideoObject
+  protected abstract lTags: LoggerTagsFn
+  protected async getOrCreateVideoChannelFromVideoObject () {
+    const channel = this.videoObject.attributedTo.find(a => a.type === 'Group')
+    if (!channel) throw new Error('Cannot find associated video channel to video ' + this.videoObject.url)
+    if (checkUrlsSameHost(channel.id, this.videoObject.id) !== true) {
+      throw new Error(`Video channel url ${channel.id} does not have the same host than video object id ${this.videoObject.id}`)
+    }
+    return getOrCreateAPActor(channel.id, 'all')
+  }
+  protected tryToGenerateThumbnail (video: MVideoThumbnail): Promise<MThumbnail> {
+    return updateVideoMiniatureFromUrl({
+      downloadUrl: getThumbnailFromIcons(this.videoObject).url,
+      video,
+      type: ThumbnailType.MINIATURE
+    }).catch(err => {
+      logger.warn('Cannot generate thumbnail of %s.', this.videoObject.id, { err, ...this.lTags() })
+      return undefined
+    })
+  }
+  protected async setPreview (video: MVideoFullLight, t?: Transaction) {
+    // Don't fetch the preview that could be big, create a placeholder instead
+    const previewIcon = getPreviewFromIcons(this.videoObject)
+    if (!previewIcon) return
+    const previewModel = updatePlaceholderThumbnail({
+      fileUrl: previewIcon.url,
+      video,
+      type: ThumbnailType.PREVIEW,
+      size: previewIcon
+    })
+    await video.addAndSaveThumbnail(previewModel, t)
+  }
+  protected async setTags (video: MVideoFullLight, t: Transaction) {
+    const tags = getTagsFromObject(this.videoObject)
+    await setVideoTags({ video, tags, transaction: t })
+  }
+  protected async setTrackers (video: MVideoFullLight, t: Transaction) {
+    const trackers = getTrackerUrls(this.videoObject, video)
+    await setVideoTrackers({ video, trackers, transaction: t })
+  }
+  protected async insertOrReplaceCaptions (video: MVideoFullLight, t: Transaction) {
+    const existingCaptions = await VideoCaptionModel.listVideoCaptions(video.id, t)
+    let captionsToCreate = getCaptionAttributesFromObject(video, this.videoObject)
+                            .map(a => new VideoCaptionModel(a) as MVideoCaption)
+    for (const existingCaption of existingCaptions) {
+      // Only keep captions that do not already exist
+      const filtered = captionsToCreate.filter(c => !c.isEqual(existingCaption))
+      // This caption already exists, we don't need to destroy and create it
+      if (filtered.length !== captionsToCreate.length) {
+        captionsToCreate = filtered
+        continue
+      }
+      // Destroy this caption that does not exist anymore
+      await existingCaption.destroy({ transaction: t })
+    }
+    for (const captionToCreate of captionsToCreate) {
+      await captionToCreate.save({ transaction: t })
+    }
+  }
+  protected async insertOrReplaceLive (video: MVideoFullLight, transaction: Transaction) {
+    const attributes = getLiveAttributesFromObject(video, this.videoObject)
+    const [ videoLive ] = await VideoLiveModel.upsert(attributes, { transaction, returning: true })
+    video.VideoLive = videoLive
+  }
+  protected async setWebTorrentFiles (video: MVideoFullLight, t: Transaction) {
+    const videoFileAttributes = getFileAttributesFromUrl(video, this.videoObject.url)
+    const newVideoFiles = videoFileAttributes.map(a => new VideoFileModel(a))
+    // Remove video files that do not exist anymore
+    const destroyTasks = deleteNonExistingModels(video.VideoFiles || [], newVideoFiles, t)
+    await Promise.all(destroyTasks)
+    // Update or add other one
+    const upsertTasks = newVideoFiles.map(f => VideoFileModel.customUpsert(f, 'video', t))
+    video.VideoFiles = await Promise.all(upsertTasks)
+  }
+  protected async setStreamingPlaylists (video: MVideoFullLight, t: Transaction) {
+    const streamingPlaylistAttributes = getStreamingPlaylistAttributesFromObject(video, this.videoObject, video.VideoFiles || [])
+    const newStreamingPlaylists = streamingPlaylistAttributes.map(a => new VideoStreamingPlaylistModel(a))
+    // Remove video playlists that do not exist anymore
+    const destroyTasks = deleteNonExistingModels(video.VideoStreamingPlaylists || [], newStreamingPlaylists, t)
+    await Promise.all(destroyTasks)
+    video.VideoStreamingPlaylists = []
+    for (const playlistAttributes of streamingPlaylistAttributes) {
+      const streamingPlaylistModel = await this.insertOrReplaceStreamingPlaylist(playlistAttributes, t)
+      streamingPlaylistModel.Video = video
+      await this.setStreamingPlaylistFiles(video, streamingPlaylistModel, playlistAttributes.tagAPObject, t)
+      video.VideoStreamingPlaylists.push(streamingPlaylistModel)
+    }
+  }
+  private async insertOrReplaceStreamingPlaylist (attributes: VideoStreamingPlaylistModel['_creationAttributes'], t: Transaction) {
+    const [ streamingPlaylist ] = await VideoStreamingPlaylistModel.upsert(attributes, { returning: true, transaction: t })
+    return streamingPlaylist as MStreamingPlaylistFilesVideo
+  }
+  private getStreamingPlaylistFiles (video: MVideoFullLight, type: VideoStreamingPlaylistType) {
+    const playlist = video.VideoStreamingPlaylists.find(s => s.type === type)
+    if (!playlist) return []
+    return playlist.VideoFiles
+  }
+  private async setStreamingPlaylistFiles (
+    video: MVideoFullLight,
+    playlistModel: MStreamingPlaylistFilesVideo,
+    tagObjects: ActivityTagObject[],
+    t: Transaction
+  ) {
+    const oldStreamingPlaylistFiles = this.getStreamingPlaylistFiles(video, playlistModel.type)
+    const newVideoFiles: MVideoFile[] = getFileAttributesFromUrl(playlistModel, tagObjects).map(a => new VideoFileModel(a))
+    const destroyTasks = deleteNonExistingModels(oldStreamingPlaylistFiles, newVideoFiles, t)
+    await Promise.all(destroyTasks)
+    // Update or add other one
+    const upsertTasks = newVideoFiles.map(f => VideoFileModel.customUpsert(f, 'streaming-playlist', t))
+    playlistModel.VideoFiles = await Promise.all(upsertTasks)
+  }
+}
diff --git a/server/lib/activitypub/videos/shared/creator.ts b/server/lib/activitypub/videos/shared/creator.ts
new file mode 100644
index 000000000..ad3b88936
--- /dev/null
+++ b/server/lib/activitypub/videos/shared/creator.ts
@@ -0,0 +1,88 @@
+import { logger, loggerTagsFactory, LoggerTagsFn } from '@server/helpers/logger'
+import { sequelizeTypescript } from '@server/initializers/database'
+import { autoBlacklistVideoIfNeeded } from '@server/lib/video-blacklist'
+import { VideoModel } from '@server/models/video/video'
+import { MThumbnail, MVideoFullLight, MVideoThumbnail } from '@server/types/models'
+import { VideoObject } from '@shared/models'
+import { APVideoAbstractBuilder } from './abstract-builder'
+import { getVideoAttributesFromObject } from './object-to-model-attributes'
+export class APVideoCreator extends APVideoAbstractBuilder {
+  protected lTags: LoggerTagsFn
+  constructor (protected readonly videoObject: VideoObject) {
+    super()
+    this.lTags = loggerTagsFactory('ap', 'video', 'create', this.videoObject.uuid, this.videoObject.id)
+  }
+  async create (waitThumbnail = false) {
+    logger.debug('Adding remote video %s.', this.videoObject.id, this.lTags())
+    const channelActor = await this.getOrCreateVideoChannelFromVideoObject()
+    const channel = channelActor.VideoChannel
+    const videoData = getVideoAttributesFromObject(channel, this.videoObject, this.videoObject.to)
+    const video = VideoModel.build(videoData) as MVideoThumbnail
+    const promiseThumbnail = this.tryToGenerateThumbnail(video)
+    let thumbnailModel: MThumbnail
+    if (waitThumbnail === true) {
+      thumbnailModel = await promiseThumbnail
+    }
+    const { autoBlacklisted, videoCreated } = await sequelizeTypescript.transaction(async t => {
+      try {
+        const videoCreated = await video.save({ transaction: t }) as MVideoFullLight
+        videoCreated.VideoChannel = channel
+        if (thumbnailModel) await videoCreated.addAndSaveThumbnail(thumbnailModel, t)
+        await this.setPreview(videoCreated, t)
+        await this.setWebTorrentFiles(videoCreated, t)
+        await this.setStreamingPlaylists(videoCreated, t)
+        await this.setTags(videoCreated, t)
+        await this.setTrackers(videoCreated, t)
+        await this.insertOrReplaceCaptions(videoCreated, t)
+        await this.insertOrReplaceLive(videoCreated, t)
+        // We added a video in this channel, set it as updated
+        await channel.setAsUpdated(t)
+        const autoBlacklisted = await autoBlacklistVideoIfNeeded({
+          video: videoCreated,
+          user: undefined,
+          isRemote: true,
+          isNew: true,
+          transaction: t
+        })
+        logger.info('Remote video with uuid %s inserted.', this.videoObject.uuid, this.lTags())
+        return { autoBlacklisted, videoCreated }
+      } catch (err) {
+        // FIXME: Use rollback hook when https://github.com/sequelize/sequelize/pull/13038 is released
+        // Remove thumbnail
+        if (thumbnailModel) await thumbnailModel.removeThumbnail()
+        throw err
+      }
+    })
+    if (waitThumbnail === false) {
+      // Error is already caught above
+      // eslint-disable-next-line @typescript-eslint/no-floating-promises
+      promiseThumbnail.then(thumbnailModel => {
+        if (!thumbnailModel) return
+        thumbnailModel = videoCreated.id
+        return thumbnailModel.save()
+      })
+    }
+    return { autoBlacklisted, videoCreated }
+  }
+}
diff --git a/server/lib/activitypub/videos/shared/index.ts b/server/lib/activitypub/videos/shared/index.ts
new file mode 100644
index 000000000..951403493
--- /dev/null
+++ b/server/lib/activitypub/videos/shared/index.ts
@@ -0,0 +1,6 @@
+export * from './abstract-builder'
+export * from './creator'
+export * from './object-to-model-attributes'
+export * from './trackers'
+export * from './url-to-object'
+export * from './video-sync-attributes'
diff --git a/server/lib/activitypub/videos/shared/object-to-model-attributes.ts b/server/lib/activitypub/videos/shared/object-to-model-attributes.ts
new file mode 100644
index 000000000..85548428c
--- /dev/null
+++ b/server/lib/activitypub/videos/shared/object-to-model-attributes.ts
@@ -0,0 +1,256 @@
+import { maxBy, minBy } from 'lodash'
+import * as magnetUtil from 'magnet-uri'
+import { basename } from 'path'
+import { isAPVideoFileUrlMetadataObject } from '@server/helpers/custom-validators/activitypub/videos'
+import { isVideoFileInfoHashValid } from '@server/helpers/custom-validators/videos'
+import { logger } from '@server/helpers/logger'
+import { getExtFromMimetype } from '@server/helpers/video'
+import { ACTIVITY_PUB, MIMETYPES, P2P_MEDIA_LOADER_PEER_VERSION, PREVIEWS_SIZE, THUMBNAILS_SIZE } from '@server/initializers/constants'
+import { generateTorrentFileName } from '@server/lib/video-paths'
+import { VideoFileModel } from '@server/models/video/video-file'
+import { VideoStreamingPlaylistModel } from '@server/models/video/video-streaming-playlist'
+import { FilteredModelAttributes } from '@server/types'
+import { MChannelId, MStreamingPlaylist, MStreamingPlaylistVideo, MVideo, MVideoFile, MVideoId } from '@server/types/models'
+import {
+  ActivityHashTagObject,
+  ActivityMagnetUrlObject,
+  ActivityPlaylistSegmentHashesObject,
+  ActivityPlaylistUrlObject,
+  ActivityTagObject,
+  ActivityUrlObject,
+  ActivityVideoUrlObject,
+  VideoObject,
+  VideoPrivacy,
+  VideoStreamingPlaylistType
+} from '@shared/models'
+import { VideoCaptionModel } from '@server/models/video/video-caption'
+function getThumbnailFromIcons (videoObject: VideoObject) {
+  let validIcons = videoObject.icon.filter(i => i.width > THUMBNAILS_SIZE.minWidth)
+  // Fallback if there are not valid icons
+  if (validIcons.length === 0) validIcons = videoObject.icon
+  return minBy(validIcons, 'width')
+}
+function getPreviewFromIcons (videoObject: VideoObject) {
+  const validIcons = videoObject.icon.filter(i => i.width > PREVIEWS_SIZE.minWidth)
+  return maxBy(validIcons, 'width')
+}
+function getTagsFromObject (videoObject: VideoObject) {
+  return videoObject.tag
+    .filter(isAPHashTagObject)
+    .map(t => t.name)
+}
+function getFileAttributesFromUrl (
+  videoOrPlaylist: MVideo | MStreamingPlaylistVideo,
+  urls: (ActivityTagObject | ActivityUrlObject)[]
+) {
+  const fileUrls = urls.filter(u => isAPVideoUrlObject(u)) as ActivityVideoUrlObject[]
+  if (fileUrls.length === 0) return []
+  const attributes: FilteredModelAttributes<VideoFileModel>[] = []
+  for (const fileUrl of fileUrls) {
+    // Fetch associated magnet uri
+    const magnet = urls.filter(isAPMagnetUrlObject)
+                       .find(u => u.height === fileUrl.height)
+    if (!magnet) throw new Error('Cannot find associated magnet uri for file ' + fileUrl.href)
+    const parsed = magnetUtil.decode(magnet.href)
+    if (!parsed || isVideoFileInfoHashValid(parsed.infoHash) === false) {
+      throw new Error('Cannot parse magnet URI ' + magnet.href)
+    }
+    const torrentUrl = Array.isArray(parsed.xs)
+      ? parsed.xs[0]
+      : parsed.xs
+    // Fetch associated metadata url, if any
+    const metadata = urls.filter(isAPVideoFileUrlMetadataObject)
+                         .find(u => {
+                           return u.height === fileUrl.height &&
+                             u.fps === fileUrl.fps &&
+                             u.rel.includes(fileUrl.mediaType)
+                         })
+    const extname = getExtFromMimetype(MIMETYPES.VIDEO.MIMETYPE_EXT, fileUrl.mediaType)
+    const resolution = fileUrl.height
+    const videoId = (videoOrPlaylist as MStreamingPlaylist).playlistUrl ? null : videoOrPlaylist.id
+    const videoStreamingPlaylistId = (videoOrPlaylist as MStreamingPlaylist).playlistUrl ? videoOrPlaylist.id : null
+    const attribute = {
+      extname,
+      infoHash: parsed.infoHash,
+      resolution,
+      size: fileUrl.size,
+      fps: fileUrl.fps || -1,
+      metadataUrl: metadata?.href,
+      // Use the name of the remote file because we don't proxify video file requests
+      filename: basename(fileUrl.href),
+      fileUrl: fileUrl.href,
+      torrentUrl,
+      // Use our own torrent name since we proxify torrent requests
+      torrentFilename: generateTorrentFileName(videoOrPlaylist, resolution),
+      // This is a video file owned by a video or by a streaming playlist
+      videoId,
+      videoStreamingPlaylistId
+    }
+    attributes.push(attribute)
+  }
+  return attributes
+}
+function getStreamingPlaylistAttributesFromObject (video: MVideoId, videoObject: VideoObject, videoFiles: MVideoFile[]) {
+  const playlistUrls = videoObject.url.filter(u => isAPStreamingPlaylistUrlObject(u)) as ActivityPlaylistUrlObject[]
+  if (playlistUrls.length === 0) return []
+  const attributes: (FilteredModelAttributes<VideoStreamingPlaylistModel> & { tagAPObject?: ActivityTagObject[] })[] = []
+  for (const playlistUrlObject of playlistUrls) {
+    const segmentsSha256UrlObject = playlistUrlObject.tag.find(isAPPlaylistSegmentHashesUrlObject)
+    let files: unknown[] = playlistUrlObject.tag.filter(u => isAPVideoUrlObject(u)) as ActivityVideoUrlObject[]
+    // FIXME: backward compatibility introduced in v2.1.0
+    if (files.length === 0) files = videoFiles
+    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, files),
+      p2pMediaLoaderPeerVersion: P2P_MEDIA_LOADER_PEER_VERSION,
+      videoId: video.id,
+      tagAPObject: playlistUrlObject.tag
+    }
+    attributes.push(attribute)
+  }
+  return attributes
+}
+function getLiveAttributesFromObject (video: MVideoId, videoObject: VideoObject) {
+  return {
+    saveReplay: videoObject.liveSaveReplay,
+    permanentLive: videoObject.permanentLive,
+    videoId: video.id
+  }
+}
+function getCaptionAttributesFromObject (video: MVideoId, videoObject: VideoObject) {
+  return videoObject.subtitleLanguage.map(c => ({
+    videoId: video.id,
+    filename: VideoCaptionModel.generateCaptionName(c.identifier),
+    language: c.identifier,
+    fileUrl: c.url
+  }))
+}
+function getVideoAttributesFromObject (videoChannel: MChannelId, videoObject: VideoObject, to: string[] = []) {
+  const privacy = to.includes(ACTIVITY_PUB.PUBLIC)
+    ? VideoPrivacy.PUBLIC
+    : VideoPrivacy.UNLISTED
+  const duration = videoObject.duration.replace(/[^\d]+/, '')
+  const language = videoObject.language?.identifier
+  const category = videoObject.category
+    ? parseInt(videoObject.category.identifier, 10)
+    : undefined
+  const licence = videoObject.licence
+    ? parseInt(videoObject.licence.identifier, 10)
+    : undefined
+  const description = videoObject.content || null
+  const support = videoObject.support || null
+  return {
+    name: videoObject.name,
+    uuid: videoObject.uuid,
+    url: videoObject.id,
+    category,
+    licence,
+    language,
+    description,
+    support,
+    nsfw: videoObject.sensitive,
+    commentsEnabled: videoObject.commentsEnabled,
+    downloadEnabled: videoObject.downloadEnabled,
+    waitTranscoding: videoObject.waitTranscoding,
+    isLive: videoObject.isLiveBroadcast,
+    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,
+    updatedAt: new Date(videoObject.updated),
+    views: videoObject.views,
+    likes: 0,
+    dislikes: 0,
+    remote: true,
+    privacy
+  }
+}
+// ---------------------------------------------------------------------------
+export {
+  getThumbnailFromIcons,
+  getPreviewFromIcons,
+  getTagsFromObject,
+  getFileAttributesFromUrl,
+  getStreamingPlaylistAttributesFromObject,
+  getLiveAttributesFromObject,
+  getCaptionAttributesFromObject,
+  getVideoAttributesFromObject
+}
+// ---------------------------------------------------------------------------
+function isAPVideoUrlObject (url: any): url is ActivityVideoUrlObject {
+  const urlMediaType = url.mediaType
+  return MIMETYPES.VIDEO.MIMETYPE_EXT[urlMediaType] && urlMediaType.startsWith('video/')
+}
+function isAPStreamingPlaylistUrlObject (url: any): url is ActivityPlaylistUrlObject {
+  return url && url.mediaType === 'application/x-mpegURL'
+}
+function isAPPlaylistSegmentHashesUrlObject (tag: any): tag is ActivityPlaylistSegmentHashesObject {
+  return tag && tag.name === 'sha256' && tag.type === 'Link' && tag.mediaType === 'application/json'
+}
+function isAPMagnetUrlObject (url: any): url is ActivityMagnetUrlObject {
+  return url && url.mediaType === 'application/x-bittorrent;x-scheme-handler/magnet'
+}
+function isAPHashTagObject (url: any): url is ActivityHashTagObject {
+  return url && url.type === 'Hashtag'
+}
diff --git a/server/lib/activitypub/videos/shared/trackers.ts b/server/lib/activitypub/videos/shared/trackers.ts
new file mode 100644
index 000000000..1c5fc4f84
--- /dev/null
+++ b/server/lib/activitypub/videos/shared/trackers.ts
@@ -0,0 +1,43 @@
+import { Transaction } from 'sequelize/types'
+import { buildRemoteVideoBaseUrl } from '@server/helpers/activitypub'
+import { isAPVideoTrackerUrlObject } from '@server/helpers/custom-validators/activitypub/videos'
+import { isArray } from '@server/helpers/custom-validators/misc'
+import { REMOTE_SCHEME } from '@server/initializers/constants'
+import { TrackerModel } from '@server/models/server/tracker'
+import { MVideo, MVideoWithHost } from '@server/types/models'
+import { ActivityTrackerUrlObject, VideoObject } from '@shared/models'
+function getTrackerUrls (object: VideoObject, video: MVideoWithHost) {
+  let wsFound = false
+  const trackers = object.url.filter(u => isAPVideoTrackerUrlObject(u))
+    .map((u: ActivityTrackerUrlObject) => {
+      if (isArray(u.rel) && u.rel.includes('websocket')) wsFound = true
+      return u.href
+    })
+  if (wsFound) return trackers
+  return [
+    buildRemoteVideoBaseUrl(video, '/tracker/socket', REMOTE_SCHEME.WS),
+    buildRemoteVideoBaseUrl(video, '/tracker/announce')
+  ]
+}
+async function setVideoTrackers (options: {
+  video: MVideo
+  trackers: string[]
+  transaction: Transaction
+}) {
+  const { video, trackers, transaction } = options
+  const trackerInstances = await TrackerModel.findOrCreateTrackers(trackers, transaction)
+  await video.$set('Trackers', trackerInstances, { transaction })
+}
+export {
+  getTrackerUrls,
+  setVideoTrackers
+}
diff --git a/server/lib/activitypub/videos/shared/url-to-object.ts b/server/lib/activitypub/videos/shared/url-to-object.ts
new file mode 100644
index 000000000..dba3e9480
--- /dev/null
+++ b/server/lib/activitypub/videos/shared/url-to-object.ts
@@ -0,0 +1,25 @@
+import { checkUrlsSameHost } from '@server/helpers/activitypub'
+import { sanitizeAndCheckVideoTorrentObject } from '@server/helpers/custom-validators/activitypub/videos'
+import { logger, loggerTagsFactory } from '@server/helpers/logger'
+import { doJSONRequest } from '@server/helpers/requests'
+import { VideoObject } from '@shared/models'
+const lTags = loggerTagsFactory('ap', 'video')
+async function fetchRemoteVideo (videoUrl: string): Promise<{ statusCode: number, videoObject: VideoObject }> {
+  logger.info('Fetching remote video %s.', videoUrl, lTags(videoUrl))
+  const { statusCode, body } = await doJSONRequest<any>(videoUrl, { activityPub: true })
+  if (sanitizeAndCheckVideoTorrentObject(body) === false || checkUrlsSameHost(body.id, videoUrl) !== true) {
+    logger.debug('Remote video JSON is not valid.', { body, ...lTags(videoUrl) })
+    return { statusCode, videoObject: undefined }
+  }
+  return { statusCode, videoObject: body }
+}
+export {
+  fetchRemoteVideo
+}
diff --git a/server/lib/activitypub/videos/shared/video-sync-attributes.ts b/server/lib/activitypub/videos/shared/video-sync-attributes.ts
new file mode 100644
index 000000000..c4e101005
--- /dev/null
+++ b/server/lib/activitypub/videos/shared/video-sync-attributes.ts
@@ -0,0 +1,94 @@
+import { logger, loggerTagsFactory } from '@server/helpers/logger'
+import { JobQueue } from '@server/lib/job-queue'
+import { AccountVideoRateModel } from '@server/models/account/account-video-rate'
+import { VideoCommentModel } from '@server/models/video/video-comment'
+import { VideoShareModel } from '@server/models/video/video-share'
+import { MVideo } from '@server/types/models'
+import { ActivitypubHttpFetcherPayload, VideoObject } from '@shared/models'
+import { crawlCollectionPage } from '../../crawl'
+import { addVideoShares } from '../../share'
+import { addVideoComments } from '../../video-comments'
+import { createRates } from '../../video-rates'
+const lTags = loggerTagsFactory('ap', 'video')
+type SyncParam = {
+  likes: boolean
+  dislikes: boolean
+  shares: boolean
+  comments: boolean
+  thumbnail: boolean
+  refreshVideo?: boolean
+}
+async function syncVideoExternalAttributes (video: MVideo, fetchedVideo: VideoObject, syncParam: SyncParam) {
+  logger.info('Adding likes/dislikes/shares/comments of video %s.', video.uuid)
+  await syncRates('like', video, fetchedVideo, syncParam.likes)
+  await syncRates('dislike', video, fetchedVideo, syncParam.dislikes)
+  await syncShares(video, fetchedVideo, syncParam.shares)
+  await syncComments(video, fetchedVideo, syncParam.comments)
+}
+// ---------------------------------------------------------------------------
+export {
+  SyncParam,
+  syncVideoExternalAttributes
+}
+// ---------------------------------------------------------------------------
+function createJob (payload: ActivitypubHttpFetcherPayload) {
+  return JobQueue.Instance.createJobWithPromise({ type: 'activitypub-http-fetcher', payload })
+}
+function syncRates (type: 'like' | 'dislike', video: MVideo, fetchedVideo: VideoObject, isSync: boolean) {
+  const uri = type === 'like'
+    ? fetchedVideo.likes
+    : fetchedVideo.dislikes
+  if (!isSync) {
+    const jobType = type === 'like'
+      ? 'video-likes'
+      : 'video-dislikes'
+    return createJob({ uri, videoId: video.id, type: jobType })
+  }
+  const handler = items => createRates(items, video, type)
+  const cleaner = crawlStartDate => AccountVideoRateModel.cleanOldRatesOf(video.id, type, crawlStartDate)
+  return crawlCollectionPage<string>(uri, handler, cleaner)
+    .catch(err => logger.error('Cannot add rate of video %s.', video.uuid, { err, rootUrl: uri, ...lTags(video.uuid, video.url) }))
+}
+function syncShares (video: MVideo, fetchedVideo: VideoObject, isSync: boolean) {
+  const uri = fetchedVideo.shares
+  if (!isSync) {
+    return createJob({ uri, videoId: video.id, type: 'video-shares' })
+  }
+  const handler = items => addVideoShares(items, video)
+  const cleaner = crawlStartDate => VideoShareModel.cleanOldSharesOf(video.id, crawlStartDate)
+  return crawlCollectionPage<string>(uri, handler, cleaner)
+    .catch(err => logger.error('Cannot add shares of video %s.', video.uuid, { err, rootUrl: uri, ...lTags(video.uuid, video.url) }))
+}
+function syncComments (video: MVideo, fetchedVideo: VideoObject, isSync: boolean) {
+  const uri = fetchedVideo.comments
+  if (!isSync) {
+    return createJob({ uri, videoId: video.id, type: 'video-comments' })
+  }
+  const handler = items => addVideoComments(items)
+  const cleaner = crawlStartDate => VideoCommentModel.cleanOldCommentsOf(video.id, crawlStartDate)
+  return crawlCollectionPage<string>(uri, handler, cleaner)
+    .catch(err => logger.error('Cannot add comments of video %s.', video.uuid, { err, rootUrl: uri, ...lTags(video.uuid, video.url) }))
+}
diff --git a/server/lib/activitypub/videos/updater.ts b/server/lib/activitypub/videos/updater.ts
new file mode 100644
index 000000000..157569414
--- /dev/null
+++ b/server/lib/activitypub/videos/updater.ts
@@ -0,0 +1,166 @@
+import { Transaction } from 'sequelize/types'
+import { resetSequelizeInstance, runInReadCommittedTransaction } from '@server/helpers/database-utils'
+import { logger, loggerTagsFactory, LoggerTagsFn } from '@server/helpers/logger'
+import { Notifier } from '@server/lib/notifier'
+import { PeerTubeSocket } from '@server/lib/peertube-socket'
+import { autoBlacklistVideoIfNeeded } from '@server/lib/video-blacklist'
+import { VideoLiveModel } from '@server/models/video/video-live'
+import { MActor, MChannelAccountLight, MChannelId, MVideoAccountLightBlacklistAllFiles, MVideoFullLight } from '@server/types/models'
+import { VideoObject, VideoPrivacy } from '@shared/models'
+import { APVideoAbstractBuilder, getVideoAttributesFromObject } from './shared'
+export class APVideoUpdater extends APVideoAbstractBuilder {
+  private readonly wasPrivateVideo: boolean
+  private readonly wasUnlistedVideo: boolean
+  private readonly videoFieldsSave: any
+  private readonly oldVideoChannel: MChannelAccountLight
+  protected lTags: LoggerTagsFn
+  constructor (
+    protected readonly videoObject: VideoObject,
+    private readonly video: MVideoAccountLightBlacklistAllFiles
+  ) {
+    super()
+    this.wasPrivateVideo = this.video.privacy === VideoPrivacy.PRIVATE
+    this.wasUnlistedVideo = this.video.privacy === VideoPrivacy.UNLISTED
+    this.oldVideoChannel = this.video.VideoChannel
+    this.videoFieldsSave = this.video.toJSON()
+    this.lTags = loggerTagsFactory('ap', 'video', 'update', video.uuid, video.url)
+  }
+  async update (overrideTo?: string[]) {
+    logger.debug(
+      'Updating remote video "%s".', this.videoObject.uuid,
+      { videoObject: this.videoObject, ...this.lTags() }
+    )
+    try {
+      const channelActor = await this.getOrCreateVideoChannelFromVideoObject()
+      const thumbnailModel = await this.tryToGenerateThumbnail(this.video)
+      this.checkChannelUpdateOrThrow(channelActor)
+      const videoUpdated = await this.updateVideo(channelActor.VideoChannel, undefined, overrideTo)
+      if (thumbnailModel) await videoUpdated.addAndSaveThumbnail(thumbnailModel)
+      await runInReadCommittedTransaction(async t => {
+        await this.setWebTorrentFiles(videoUpdated, t)
+        await this.setStreamingPlaylists(videoUpdated, t)
+      })
+      await Promise.all([
+        runInReadCommittedTransaction(t => this.setTags(videoUpdated, t)),
+        runInReadCommittedTransaction(t => this.setTrackers(videoUpdated, t)),
+        this.setOrDeleteLive(videoUpdated),
+        this.setPreview(videoUpdated)
+      ])
+      await runInReadCommittedTransaction(t => this.setCaptions(videoUpdated, t))
+      await autoBlacklistVideoIfNeeded({
+        video: videoUpdated,
+        user: undefined,
+        isRemote: true,
+        isNew: false,
+        transaction: undefined
+      })
+      // Notify our users?
+      if (this.wasPrivateVideo || this.wasUnlistedVideo) {
+        Notifier.Instance.notifyOnNewVideoIfNeeded(videoUpdated)
+      }
+      if (videoUpdated.isLive) {
+        PeerTubeSocket.Instance.sendVideoLiveNewState(videoUpdated)
+        PeerTubeSocket.Instance.sendVideoViewsUpdate(videoUpdated)
+      }
+      logger.info('Remote video with uuid %s updated', this.videoObject.uuid, this.lTags())
+      return videoUpdated
+    } catch (err) {
+      this.catchUpdateError(err)
+    }
+  }
+  // Check we can update the channel: we trust the remote server
+  private checkChannelUpdateOrThrow (newChannelActor: MActor) {
+    if (!this.oldVideoChannel.Actor.serverId || !newChannelActor.serverId) {
+      throw new Error('Cannot check old channel/new channel validity because `serverId` is null')
+    }
+    if (this.oldVideoChannel.Actor.serverId !== newChannelActor.serverId) {
+      throw new Error(`New channel ${newChannelActor.url} is not on the same server than new channel ${this.oldVideoChannel.Actor.url}`)
+    }
+  }
+  private updateVideo (channel: MChannelId, transaction?: Transaction, overrideTo?: string[]) {
+    const to = overrideTo || this.videoObject.to
+    const videoData = getVideoAttributesFromObject(channel, this.videoObject, to)
+    this.video.name = videoData.name
+    this.video.uuid = videoData.uuid
+    this.video.url = videoData.url
+    this.video.category = videoData.category
+    this.video.licence = videoData.licence
+    this.video.language = videoData.language
+    this.video.description = videoData.description
+    this.video.support = videoData.support
+    this.video.nsfw = videoData.nsfw
+    this.video.commentsEnabled = videoData.commentsEnabled
+    this.video.downloadEnabled = videoData.downloadEnabled
+    this.video.waitTranscoding = videoData.waitTranscoding
+    this.video.state = videoData.state
+    this.video.duration = videoData.duration
+    this.video.createdAt = videoData.createdAt
+    this.video.publishedAt = videoData.publishedAt
+    this.video.originallyPublishedAt = videoData.originallyPublishedAt
+    this.video.privacy = videoData.privacy
+    this.video.channelId = videoData.channelId
+    this.video.views = videoData.views
+    this.video.isLive = videoData.isLive
+    // Ensures we update the updatedAt attribute, even if main attributes did not change
+    this.video.changed('updatedAt', true)
+    return this.video.save({ transaction }) as Promise<MVideoFullLight>
+  }
+  private async setCaptions (videoUpdated: MVideoFullLight, t: Transaction) {
+    await this.insertOrReplaceCaptions(videoUpdated, t)
+  }
+  private async setOrDeleteLive (videoUpdated: MVideoFullLight, transaction?: Transaction) {
+    if (!this.video.isLive) return
+    if (this.video.isLive) return this.insertOrReplaceLive(videoUpdated, transaction)
+    // Delete existing live if it exists
+    await VideoLiveModel.destroy({
+      where: {
+        videoId: this.video.id
+      },
+      transaction
+    })
+    videoUpdated.VideoLive = null
+  }
+  private catchUpdateError (err: Error) {
+    if (this.video !== undefined && this.videoFieldsSave !== undefined) {
+      resetSequelizeInstance(this.video, this.videoFieldsSave)
+    }
+    // This is just a debug because we will retry the insert
+    logger.debug('Cannot update the remote video.', { err, ...this.lTags() })
+    throw err
+  }
+}
diff --git a/server/lib/auth/oauth-model.ts b/server/lib/auth/oauth-model.ts
index b9c69eb2d..ae728d080 100644
--- a/server/lib/auth/oauth-model.ts
+++ b/server/lib/auth/oauth-model.ts
@@ -1,7 +1,7 @@
 import * as express from 'express'
 import { AccessDeniedError } from 'oauth2-server'
 import { PluginManager } from '@server/lib/plugins/plugin-manager'
-import { ActorModel } from '@server/models/activitypub/actor'
+import { ActorModel } from '@server/models/actor/actor'
 import { MOAuthClient } from '@server/types/models'
 import { MOAuthTokenUser } from '@server/types/models/oauth/oauth-token'
 import { MUser } from '@server/types/models/user/user'
@@ -9,7 +9,7 @@ import { UserAdminFlag } from '@shared/models/users/user-flag.model'
 import { UserRole } from '@shared/models/users/user-role'
 import { logger } from '../../helpers/logger'
 import { CONFIG } from '../../initializers/config'
-import { UserModel } from '../../models/account/user'
+import { UserModel } from '../../models/user/user'
 import { OAuthClientModel } from '../../models/oauth/oauth-client'
 import { OAuthTokenModel } from '../../models/oauth/oauth-token'
 import { createUserAccountAndChannelAndPlaylist } from '../user'
diff --git a/server/lib/client-html.ts b/server/lib/client-html.ts
index 203bd3893..72194416d 100644
--- a/server/lib/client-html.ts
+++ b/server/lib/client-html.ts
@@ -2,12 +2,14 @@ import * as express from 'express'
 import { readFile } from 'fs-extra'
 import { join } from 'path'
 import validator from 'validator'
+import { escapeHTML } from '@shared/core-utils/renderer'
+import { HTMLServerConfig } from '@shared/models'
 import { buildFileLocale, getDefaultLocale, is18nLocale, POSSIBLE_LOCALES } from '../../shared/core-utils/i18n/i18n'
 import { HttpStatusCode } from '../../shared/core-utils/miscs/http-error-codes'
 import { VideoPlaylistPrivacy, VideoPrivacy } from '../../shared/models/videos'
 import { isTestInstance, sha256 } from '../helpers/core-utils'
-import { escapeHTML } from '@shared/core-utils/renderer'
 import { logger } from '../helpers/logger'
+import { mdToPlainText } from '../helpers/markdown'
 import { CONFIG } from '../initializers/config'
 import {
  ACCEPT_HEADERS,
@@ -19,12 +21,13 @@ import {
  WEBSERVER
 } from '../initializers/constants'
 import { AccountModel } from '../models/account/account'
+import { getActivityStreamDuration } from '../models/video/formatter/video-format-utils'
 import { VideoModel } from '../models/video/video'
 import { VideoChannelModel } from '../models/video/video-channel'
-import { getActivityStreamDuration } from '../models/video/video-format-utils'
 import { VideoPlaylistModel } from '../models/video/video-playlist'
 import { MAccountActor, MChannelActor } from '../types/models'
-import { mdToPlainText } from '../helpers/markdown'
+import { ServerConfigManager } from './server-config-manager'
+import { toCompleteUUID } from '@server/helpers/custom-validators/misc'
 type Tags = {
  ogType: string
@@ -76,7 +79,9 @@ class ClientHtml {
    return customHtml
  }
-  static async getWatchHTMLPage (videoId: string, req: express.Request, res: express.Response) {
+  static async getWatchHTMLPage (videoIdArg: string, req: express.Request, res: express.Response) {
+    const videoId = toCompleteUUID(videoIdArg)
    // Let Angular application handle errors
    if (!validator.isInt(videoId) && !validator.isUUID(videoId, 4)) {
      res.status(HttpStatusCode.NOT_FOUND_404)
@@ -134,7 +139,9 @@ class ClientHtml {
    return customHtml
  }
-  static async getWatchPlaylistHTMLPage (videoPlaylistId: string, req: express.Request, res: express.Response) {
+  static async getWatchPlaylistHTMLPage (videoPlaylistIdArg: string, req: express.Request, res: express.Response) {
+    const videoPlaylistId = toCompleteUUID(videoPlaylistIdArg)
    // Let Angular application handle errors
    if (!validator.isInt(videoPlaylistId) && !validator.isUUID(videoPlaylistId, 4)) {
      res.status(HttpStatusCode.NOT_FOUND_404)
@@ -196,11 +203,22 @@ class ClientHtml {
  }
  static async getAccountHTMLPage (nameWithHost: string, req: express.Request, res: express.Response) {
-    return this.getAccountOrChannelHTMLPage(() => AccountModel.loadByNameWithHost(nameWithHost), req, res)
+    const accountModelPromise = AccountModel.loadByNameWithHost(nameWithHost)
+    return this.getAccountOrChannelHTMLPage(() => accountModelPromise, req, res)
  }
  static async getVideoChannelHTMLPage (nameWithHost: string, req: express.Request, res: express.Response) {
-    return this.getAccountOrChannelHTMLPage(() => VideoChannelModel.loadByNameWithHostAndPopulateAccount(nameWithHost), req, res)
+    const videoChannelModelPromise = VideoChannelModel.loadByNameWithHostAndPopulateAccount(nameWithHost)
+    return this.getAccountOrChannelHTMLPage(() => videoChannelModelPromise, req, res)
+  }
+  static async getActorHTMLPage (nameWithHost: string, req: express.Request, res: express.Response) {
+    const [ account, channel ] = await Promise.all([
+      AccountModel.loadByNameWithHost(nameWithHost),
+      VideoChannelModel.loadByNameWithHostAndPopulateAccount(nameWithHost)
+    ])
+    return this.getAccountOrChannelHTMLPage(() => Promise.resolve(account || channel), req, res)
  }
  static async getEmbedHTML () {
@@ -209,11 +227,14 @@ class ClientHtml {
    if (!isTestInstance() && ClientHtml.htmlCache[path]) return ClientHtml.htmlCache[path]
    const buffer = await readFile(path)
+    const serverConfig = await ServerConfigManager.Instance.getHTMLServerConfig()
    let html = buffer.toString()
    html = await ClientHtml.addAsyncPluginCSS(html)
    html = ClientHtml.addCustomCSS(html)
    html = ClientHtml.addTitleTag(html)
+    html = ClientHtml.addDescriptionTag(html)
+    html = ClientHtml.addServerConfig(html, serverConfig)
    ClientHtml.htmlCache[path] = html
@@ -275,6 +296,7 @@ class ClientHtml {
    if (!isTestInstance() && ClientHtml.htmlCache[path]) return ClientHtml.htmlCache[path]
    const buffer = await readFile(path)
+    const serverConfig = await ServerConfigManager.Instance.getHTMLServerConfig()
    let html = buffer.toString()
@@ -283,6 +305,7 @@ class ClientHtml {
    html = ClientHtml.addFaviconContentHash(html)
    html = ClientHtml.addLogoContentHash(html)
    html = ClientHtml.addCustomCSS(html)
+    html = ClientHtml.addServerConfig(html, serverConfig)
    html = await ClientHtml.addAsyncPluginCSS(html)
    ClientHtml.htmlCache[path] = html
@@ -355,6 +378,13 @@ class ClientHtml {
    return htmlStringPage.replace(CUSTOM_HTML_TAG_COMMENTS.CUSTOM_CSS, styleTag)
  }
+  private static addServerConfig (htmlStringPage: string, serverConfig: HTMLServerConfig) {
+    const serverConfigString = JSON.stringify(serverConfig)
+    const configScriptTag = `<script type="application/javascript">window.PeerTubeServerConfig = '${serverConfigString}'</script>`
+    return htmlStringPage.replace(CUSTOM_HTML_TAG_COMMENTS.SERVER_CONFIG, configScriptTag)
+  }
  private static async addAsyncPluginCSS (htmlStringPage: string) {
    const globalCSSContent = await readFile(PLUGIN_GLOBAL_CSS_PATH)
    if (globalCSSContent.byteLength === 0) return htmlStringPage
@@ -524,11 +554,11 @@ async function serveIndexHTML (req: express.Request, res: express.Response) {
      return
    } catch (err) {
      logger.error('Cannot generate HTML page.', err)
-      return res.sendStatus(HttpStatusCode.INTERNAL_SERVER_ERROR_500)
+      return res.status(HttpStatusCode.INTERNAL_SERVER_ERROR_500).end()
    }
  }
-  return res.sendStatus(HttpStatusCode.NOT_ACCEPTABLE_406)
+  return res.status(HttpStatusCode.NOT_ACCEPTABLE_406).end()
 }
 // ---------------------------------------------------------------------------
diff --git a/server/lib/config.ts b/server/lib/config.ts
deleted file mode 100644
index b4c4c9299..000000000
--- a/server/lib/config.ts
+++ /dev/null
@@ -1,255 +0,0 @@
-import { isSignupAllowed, isSignupAllowedForCurrentIP } from '@server/helpers/signup'
-import { getServerCommit } from '@server/helpers/utils'
-import { CONFIG, isEmailEnabled } from '@server/initializers/config'
-import { CONSTRAINTS_FIELDS, DEFAULT_THEME_NAME, PEERTUBE_VERSION } from '@server/initializers/constants'
-import { RegisteredExternalAuthConfig, RegisteredIdAndPassAuthConfig, ServerConfig } from '@shared/models'
-import { Hooks } from './plugins/hooks'
-import { PluginManager } from './plugins/plugin-manager'
-import { getThemeOrDefault } from './plugins/theme-utils'
-import { getEnabledResolutions } from './video-transcoding'
-import { VideoTranscodingProfilesManager } from './video-transcoding-profiles'
-let serverCommit: string
-async function getServerConfig (ip?: string): Promise<ServerConfig> {
-  if (serverCommit === undefined) serverCommit = await getServerCommit()
-  const { allowed } = await Hooks.wrapPromiseFun(
-    isSignupAllowed,
-    {
-      ip
-    },
-    'filter:api.user.signup.allowed.result'
-  )
-  const allowedForCurrentIP = isSignupAllowedForCurrentIP(ip)
-  const defaultTheme = getThemeOrDefault(CONFIG.THEME.DEFAULT, DEFAULT_THEME_NAME)
-  return {
-    instance: {
-      name: CONFIG.INSTANCE.NAME,
-      shortDescription: CONFIG.INSTANCE.SHORT_DESCRIPTION,
-      isNSFW: CONFIG.INSTANCE.IS_NSFW,
-      defaultNSFWPolicy: CONFIG.INSTANCE.DEFAULT_NSFW_POLICY,
-      defaultClientRoute: CONFIG.INSTANCE.DEFAULT_CLIENT_ROUTE,
-      customizations: {
-        javascript: CONFIG.INSTANCE.CUSTOMIZATIONS.JAVASCRIPT,
-        css: CONFIG.INSTANCE.CUSTOMIZATIONS.CSS
-      }
-    },
-    search: {
-      remoteUri: {
-        users: CONFIG.SEARCH.REMOTE_URI.USERS,
-        anonymous: CONFIG.SEARCH.REMOTE_URI.ANONYMOUS
-      },
-      searchIndex: {
-        enabled: CONFIG.SEARCH.SEARCH_INDEX.ENABLED,
-        url: CONFIG.SEARCH.SEARCH_INDEX.URL,
-        disableLocalSearch: CONFIG.SEARCH.SEARCH_INDEX.DISABLE_LOCAL_SEARCH,
-        isDefaultSearch: CONFIG.SEARCH.SEARCH_INDEX.IS_DEFAULT_SEARCH
-      }
-    },
-    plugin: {
-      registered: getRegisteredPlugins(),
-      registeredExternalAuths: getExternalAuthsPlugins(),
-      registeredIdAndPassAuths: getIdAndPassAuthPlugins()
-    },
-    theme: {
-      registered: getRegisteredThemes(),
-      default: defaultTheme
-    },
-    email: {
-      enabled: isEmailEnabled()
-    },
-    contactForm: {
-      enabled: CONFIG.CONTACT_FORM.ENABLED
-    },
-    serverVersion: PEERTUBE_VERSION,
-    serverCommit,
-    signup: {
-      allowed,
-      allowedForCurrentIP,
-      requiresEmailVerification: CONFIG.SIGNUP.REQUIRES_EMAIL_VERIFICATION
-    },
-    transcoding: {
-      hls: {
-        enabled: CONFIG.TRANSCODING.HLS.ENABLED
-      },
-      webtorrent: {
-        enabled: CONFIG.TRANSCODING.WEBTORRENT.ENABLED
-      },
-      enabledResolutions: getEnabledResolutions('vod'),
-      profile: CONFIG.TRANSCODING.PROFILE,
-      availableProfiles: VideoTranscodingProfilesManager.Instance.getAvailableProfiles('vod')
-    },
-    live: {
-      enabled: CONFIG.LIVE.ENABLED,
-      allowReplay: CONFIG.LIVE.ALLOW_REPLAY,
-      maxDuration: CONFIG.LIVE.MAX_DURATION,
-      maxInstanceLives: CONFIG.LIVE.MAX_INSTANCE_LIVES,
-      maxUserLives: CONFIG.LIVE.MAX_USER_LIVES,
-      transcoding: {
-        enabled: CONFIG.LIVE.TRANSCODING.ENABLED,
-        enabledResolutions: getEnabledResolutions('live'),
-        profile: CONFIG.LIVE.TRANSCODING.PROFILE,
-        availableProfiles: VideoTranscodingProfilesManager.Instance.getAvailableProfiles('live')
-      },
-      rtmp: {
-        port: CONFIG.LIVE.RTMP.PORT
-      }
-    },
-    import: {
-      videos: {
-        http: {
-          enabled: CONFIG.IMPORT.VIDEOS.HTTP.ENABLED
-        },
-        torrent: {
-          enabled: CONFIG.IMPORT.VIDEOS.TORRENT.ENABLED
-        }
-      }
-    },
-    autoBlacklist: {
-      videos: {
-        ofUsers: {
-          enabled: CONFIG.AUTO_BLACKLIST.VIDEOS.OF_USERS.ENABLED
-        }
-      }
-    },
-    avatar: {
-      file: {
-        size: {
-          max: CONSTRAINTS_FIELDS.ACTORS.IMAGE.FILE_SIZE.max
-        },
-        extensions: CONSTRAINTS_FIELDS.ACTORS.IMAGE.EXTNAME
-      }
-    },
-    banner: {
-      file: {
-        size: {
-          max: CONSTRAINTS_FIELDS.ACTORS.IMAGE.FILE_SIZE.max
-        },
-        extensions: CONSTRAINTS_FIELDS.ACTORS.IMAGE.EXTNAME
-      }
-    },
-    video: {
-      image: {
-        extensions: CONSTRAINTS_FIELDS.VIDEOS.IMAGE.EXTNAME,
-        size: {
-          max: CONSTRAINTS_FIELDS.VIDEOS.IMAGE.FILE_SIZE.max
-        }
-      },
-      file: {
-        extensions: CONSTRAINTS_FIELDS.VIDEOS.EXTNAME
-      }
-    },
-    videoCaption: {
-      file: {
-        size: {
-          max: CONSTRAINTS_FIELDS.VIDEO_CAPTIONS.CAPTION_FILE.FILE_SIZE.max
-        },
-        extensions: CONSTRAINTS_FIELDS.VIDEO_CAPTIONS.CAPTION_FILE.EXTNAME
-      }
-    },
-    user: {
-      videoQuota: CONFIG.USER.VIDEO_QUOTA,
-      videoQuotaDaily: CONFIG.USER.VIDEO_QUOTA_DAILY
-    },
-    trending: {
-      videos: {
-        intervalDays: CONFIG.TRENDING.VIDEOS.INTERVAL_DAYS,
-        algorithms: {
-          enabled: CONFIG.TRENDING.VIDEOS.ALGORITHMS.ENABLED,
-          default: CONFIG.TRENDING.VIDEOS.ALGORITHMS.DEFAULT
-        }
-      }
-    },
-    tracker: {
-      enabled: CONFIG.TRACKER.ENABLED
-    },
-    followings: {
-      instance: {
-        autoFollowIndex: {
-          indexUrl: CONFIG.FOLLOWINGS.INSTANCE.AUTO_FOLLOW_INDEX.INDEX_URL
-        }
-      }
-    },
-    broadcastMessage: {
-      enabled: CONFIG.BROADCAST_MESSAGE.ENABLED,
-      message: CONFIG.BROADCAST_MESSAGE.MESSAGE,
-      level: CONFIG.BROADCAST_MESSAGE.LEVEL,
-      dismissable: CONFIG.BROADCAST_MESSAGE.DISMISSABLE
-    }
-  }
-}
-function getRegisteredThemes () {
-  return PluginManager.Instance.getRegisteredThemes()
-                      .map(t => ({
-                        name: t.name,
-                        version: t.version,
-                        description: t.description,
-                        css: t.css,
-                        clientScripts: t.clientScripts
-                      }))
-}
-function getRegisteredPlugins () {
-  return PluginManager.Instance.getRegisteredPlugins()
-                      .map(p => ({
-                        name: p.name,
-                        version: p.version,
-                        description: p.description,
-                        clientScripts: p.clientScripts
-                      }))
-}
-// ---------------------------------------------------------------------------
-export {
-  getServerConfig,
-  getRegisteredThemes,
-  getRegisteredPlugins
-}
-// ---------------------------------------------------------------------------
-function getIdAndPassAuthPlugins () {
-  const result: RegisteredIdAndPassAuthConfig[] = []
-  for (const p of PluginManager.Instance.getIdAndPassAuths()) {
-    for (const auth of p.idAndPassAuths) {
-      result.push({
-        npmName: p.npmName,
-        name: p.name,
-        version: p.version,
-        authName: auth.authName,
-        weight: auth.getWeight()
-      })
-    }
-  }
-  return result
-}
-function getExternalAuthsPlugins () {
-  const result: RegisteredExternalAuthConfig[] = []
-  for (const p of PluginManager.Instance.getExternalAuths()) {
-    for (const auth of p.externalAuths) {
-      result.push({
-        npmName: p.npmName,
-        name: p.name,
-        version: p.version,
-        authName: auth.authName,
-        authDisplayName: auth.authDisplayName()
-      })
-    }
-  }
-  return result
-}
diff --git a/server/lib/job-queue/handlers/activitypub-follow.ts b/server/lib/job-queue/handlers/activitypub-follow.ts
index 82c95be80..f896d7af4 100644
--- a/server/lib/job-queue/handlers/activitypub-follow.ts
+++ b/server/lib/job-queue/handlers/activitypub-follow.ts
@@ -1,18 +1,17 @@
 import * as Bull from 'bull'
-import { logger } from '../../../helpers/logger'
+import { getLocalActorFollowActivityPubUrl } from '@server/lib/activitypub/url'
-import { REMOTE_SCHEME, WEBSERVER } from '../../../initializers/constants'
+import { ActivitypubFollowPayload } from '@shared/models'
-import { sendFollow } from '../../activitypub/send'
 import { sanitizeHost } from '../../../helpers/core-utils'
-import { loadActorUrlOrGetFromWebfinger } from '../../../helpers/webfinger'
-import { getOrCreateActorAndServerAndModel } from '../../activitypub/actor'
 import { retryTransactionWrapper } from '../../../helpers/database-utils'
-import { ActorFollowModel } from '../../../models/activitypub/actor-follow'
+import { logger } from '../../../helpers/logger'
-import { ActorModel } from '../../../models/activitypub/actor'
+import { REMOTE_SCHEME, WEBSERVER } from '../../../initializers/constants'
-import { Notifier } from '../../notifier'
 import { sequelizeTypescript } from '../../../initializers/database'
+import { ActorModel } from '../../../models/actor/actor'
+import { ActorFollowModel } from '../../../models/actor/actor-follow'
 import { MActor, MActorFollowActors, MActorFull } from '../../../types/models'
-import { ActivitypubFollowPayload } from '@shared/models'
+import { getOrCreateAPActor, loadActorUrlOrGetFromWebfinger } from '../../activitypub/actors'
-import { getLocalActorFollowActivityPubUrl } from '@server/lib/activitypub/url'
+import { sendFollow } from '../../activitypub/send'
+import { Notifier } from '../../notifier'
 async function processActivityPubFollow (job: Bull.Job) {
  const payload = job.data as ActivitypubFollowPayload
@@ -26,7 +25,7 @@ async function processActivityPubFollow (job: Bull.Job) {
  } else {
    const sanitizedHost = sanitizeHost(host, REMOTE_SCHEME.HTTP)
    const actorUrl = await loadActorUrlOrGetFromWebfinger(payload.name + '@' + sanitizedHost)
-    targetActor = await getOrCreateActorAndServerAndModel(actorUrl, 'all')
+    targetActor = await getOrCreateAPActor(actorUrl, 'all')
  }
  if (payload.assertIsChannel && !targetActor.VideoChannel) {
diff --git a/server/lib/job-queue/handlers/activitypub-http-broadcast.ts b/server/lib/job-queue/handlers/activitypub-http-broadcast.ts
index c69ff9e83..d4b328635 100644
--- a/server/lib/job-queue/handlers/activitypub-http-broadcast.ts
+++ b/server/lib/job-queue/handlers/activitypub-http-broadcast.ts
@@ -3,7 +3,7 @@ import * as Bull from 'bull'
 import { ActivitypubHttpBroadcastPayload } from '@shared/models'
 import { logger } from '../../../helpers/logger'
 import { doRequest } from '../../../helpers/requests'
-import { BROADCAST_CONCURRENCY, REQUEST_TIMEOUT } from '../../../initializers/constants'
+import { BROADCAST_CONCURRENCY } from '../../../initializers/constants'
 import { ActorFollowScoreCache } from '../../files-cache'
 import { buildGlobalHeaders, buildSignedRequestOptions, computeBody } from './utils/activitypub-http-utils'
@@ -19,7 +19,6 @@ async function processActivityPubHttpBroadcast (job: Bull.Job) {
    method: 'POST' as 'POST',
    json: body,
    httpSignature: httpSignatureOptions,
-    timeout: REQUEST_TIMEOUT,
    headers: buildGlobalHeaders(body)
  }
diff --git a/server/lib/job-queue/handlers/activitypub-http-fetcher.ts b/server/lib/job-queue/handlers/activitypub-http-fetcher.ts
index e210ac3ef..ab9675cae 100644
--- a/server/lib/job-queue/handlers/activitypub-http-fetcher.ts
+++ b/server/lib/job-queue/handlers/activitypub-http-fetcher.ts
@@ -1,14 +1,13 @@
 import * as Bull from 'bull'
 import { ActivitypubHttpFetcherPayload, FetchType } from '@shared/models'
 import { logger } from '../../../helpers/logger'
-import { AccountModel } from '../../../models/account/account'
 import { AccountVideoRateModel } from '../../../models/account/account-video-rate'
 import { VideoModel } from '../../../models/video/video'
 import { VideoCommentModel } from '../../../models/video/video-comment'
 import { VideoShareModel } from '../../../models/video/video-share'
-import { MAccountDefault, MVideoFullLight } from '../../../types/models'
+import { MVideoFullLight } from '../../../types/models'
 import { crawlCollectionPage } from '../../activitypub/crawl'
-import { createAccountPlaylists } from '../../activitypub/playlist'
+import { createAccountPlaylists } from '../../activitypub/playlists'
 import { processActivities } from '../../activitypub/process'
 import { addVideoShares } from '../../activitypub/share'
 import { addVideoComments } from '../../activitypub/video-comments'
@@ -22,16 +21,13 @@ async function processActivityPubHttpFetcher (job: Bull.Job) {
  let video: MVideoFullLight
  if (payload.videoId) video = await VideoModel.loadAndPopulateAccountAndServerAndTags(payload.videoId)
-  let account: MAccountDefault
-  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, fromFetch: true }),
    '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),
-    'account-playlists': items => createAccountPlaylists(items, account)
+    'account-playlists': items => createAccountPlaylists(items)
  }
  const cleanerType: { [ id in FetchType ]?: (crawlStartDate: Date) => Promise<any> } = {
diff --git a/server/lib/job-queue/handlers/activitypub-http-unicast.ts b/server/lib/job-queue/handlers/activitypub-http-unicast.ts
index 585dad671..9e561c6b7 100644
--- a/server/lib/job-queue/handlers/activitypub-http-unicast.ts
+++ b/server/lib/job-queue/handlers/activitypub-http-unicast.ts
@@ -2,7 +2,6 @@ import * as Bull from 'bull'
 import { ActivitypubHttpUnicastPayload } from '@shared/models'
 import { logger } from '../../../helpers/logger'
 import { doRequest } from '../../../helpers/requests'
-import { REQUEST_TIMEOUT } from '../../../initializers/constants'
 import { ActorFollowScoreCache } from '../../files-cache'
 import { buildGlobalHeaders, buildSignedRequestOptions, computeBody } from './utils/activitypub-http-utils'
@@ -19,7 +18,6 @@ async function processActivityPubHttpUnicast (job: Bull.Job) {
    method: 'POST' as 'POST',
    json: body,
    httpSignature: httpSignatureOptions,
-    timeout: REQUEST_TIMEOUT,
    headers: buildGlobalHeaders(body)
  }
diff --git a/server/lib/job-queue/handlers/activitypub-refresher.ts b/server/lib/job-queue/handlers/activitypub-refresher.ts
index 666e56868..d97e50ebc 100644
--- a/server/lib/job-queue/handlers/activitypub-refresher.ts
+++ b/server/lib/job-queue/handlers/activitypub-refresher.ts
@@ -1,12 +1,12 @@
 import * as Bull from 'bull'
+import { refreshVideoPlaylistIfNeeded } from '@server/lib/activitypub/playlists'
+import { refreshVideoIfNeeded } from '@server/lib/activitypub/videos'
+import { loadVideoByUrl } from '@server/lib/model-loaders'
+import { RefreshPayload } from '@shared/models'
 import { logger } from '../../../helpers/logger'
-import { fetchVideoByUrl } from '../../../helpers/video'
+import { ActorModel } from '../../../models/actor/actor'
-import { refreshActorIfNeeded } from '../../activitypub/actor'
-import { refreshVideoIfNeeded } from '../../activitypub/videos'
-import { ActorModel } from '../../../models/activitypub/actor'
 import { VideoPlaylistModel } from '../../../models/video/video-playlist'
-import { RefreshPayload } from '@shared/models'
+import { refreshActorIfNeeded } from '../../activitypub/actors'
-import { refreshVideoPlaylistIfNeeded } from '@server/lib/activitypub/playlist'
 async function refreshAPObject (job: Bull.Job) {
  const payload = job.data as RefreshPayload
@@ -30,7 +30,7 @@ async function refreshVideo (videoUrl: string) {
  const fetchType = 'all' as 'all'
  const syncParam = { likes: true, dislikes: true, shares: true, comments: true, thumbnail: true }
-  const videoFromDatabase = await fetchVideoByUrl(videoUrl, fetchType)
+  const videoFromDatabase = await loadVideoByUrl(videoUrl, fetchType)
  if (videoFromDatabase) {
    const refreshOptions = {
      video: videoFromDatabase,
@@ -47,7 +47,7 @@ async function refreshActor (actorUrl: string) {
  const actor = await ActorModel.loadByUrlAndPopulateAccountAndChannel(actorUrl)
  if (actor) {
-    await refreshActorIfNeeded(actor, fetchType)
+    await refreshActorIfNeeded({ actor, fetchedType: fetchType })
  }
 }
diff --git a/server/lib/job-queue/handlers/actor-keys.ts b/server/lib/job-queue/handlers/actor-keys.ts
index 125307843..60ac61afd 100644
--- a/server/lib/job-queue/handlers/actor-keys.ts
+++ b/server/lib/job-queue/handlers/actor-keys.ts
@@ -1,6 +1,6 @@
 import * as Bull from 'bull'
-import { generateAndSaveActorKeys } from '@server/lib/activitypub/actor'
+import { generateAndSaveActorKeys } from '@server/lib/activitypub/actors'
-import { ActorModel } from '@server/models/activitypub/actor'
+import { ActorModel } from '@server/models/actor/actor'
 import { ActorKeysPayload } from '@shared/models'
 import { logger } from '../../../helpers/logger'
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 e8a91450d..37e7c1fad 100644
--- a/server/lib/job-queue/handlers/utils/activitypub-http-utils.ts
+++ b/server/lib/job-queue/handlers/utils/activitypub-http-utils.ts
@@ -1,10 +1,10 @@
+import { buildDigest } from '@server/helpers/peertube-crypto'
+import { getServerActor } from '@server/models/application/application'
+import { ContextType } from '@shared/models/activitypub/context'
 import { buildSignedActivity } from '../../../../helpers/activitypub'
-import { ActorModel } from '../../../../models/activitypub/actor'
 import { ACTIVITY_PUB, HTTP_SIGNATURE } from '../../../../initializers/constants'
+import { ActorModel } from '../../../../models/actor/actor'
 import { MActor } from '../../../../types/models'
-import { getServerActor } from '@server/models/application/application'
-import { buildDigest } from '@server/helpers/peertube-crypto'
-import { ContextType } from '@shared/models/activitypub/context'
 type Payload <T> = { body: T, contextType?: ContextType, signatureActorId?: number }
diff --git a/server/lib/job-queue/handlers/video-file-import.ts b/server/lib/job-queue/handlers/video-file-import.ts
index 71f2cafcd..187cb652e 100644
--- a/server/lib/job-queue/handlers/video-file-import.ts
+++ b/server/lib/job-queue/handlers/video-file-import.ts
@@ -1,9 +1,9 @@
 import * as Bull from 'bull'
 import { copy, stat } from 'fs-extra'
-import { extname } from 'path'
+import { getLowercaseExtension } from '@server/helpers/core-utils'
 import { createTorrentAndSetInfoHash } from '@server/helpers/webtorrent'
 import { generateVideoFilename, getVideoFilePath } from '@server/lib/video-paths'
-import { UserModel } from '@server/models/account/user'
+import { UserModel } from '@server/models/user/user'
 import { MVideoFullLight } from '@server/types/models'
 import { VideoFileImportPayload } from '@shared/models'
 import { getVideoFileFPS, getVideoFileResolution } from '../../../helpers/ffprobe-utils'
@@ -55,7 +55,7 @@ async function updateVideoFile (video: MVideoFullLight, inputFilePath: string) {
  const { size } = await stat(inputFilePath)
  const fps = await getVideoFileFPS(inputFilePath)
-  const fileExt = extname(inputFilePath)
+  const fileExt = getLowercaseExtension(inputFilePath)
  const currentVideoFile = video.VideoFiles.find(videoFile => videoFile.resolution === videoFileResolution)
diff --git a/server/lib/job-queue/handlers/video-import.ts b/server/lib/job-queue/handlers/video-import.ts
index ed2c5eac0..55498003d 100644
--- a/server/lib/job-queue/handlers/video-import.ts
+++ b/server/lib/job-queue/handlers/video-import.ts
@@ -1,9 +1,11 @@
 import * as Bull from 'bull'
 import { move, remove, stat } from 'fs-extra'
-import { extname } from 'path'
+import { getLowercaseExtension } from '@server/helpers/core-utils'
 import { retryTransactionWrapper } from '@server/helpers/database-utils'
+import { YoutubeDL } from '@server/helpers/youtube-dl'
 import { isPostImportVideoAccepted } from '@server/lib/moderation'
 import { Hooks } from '@server/lib/plugins/hooks'
+import { ServerConfigManager } from '@server/lib/server-config-manager'
 import { isAbleToUploadVideo } from '@server/lib/user'
 import { addOptimizeOrMergeAudioJob } from '@server/lib/video'
 import { generateVideoFilename, getVideoFilePath } from '@server/lib/video-paths'
@@ -23,7 +25,6 @@ import { getDurationFromVideoFile, getVideoFileFPS, getVideoFileResolution } fro
 import { logger } from '../../../helpers/logger'
 import { getSecureTorrentName } from '../../../helpers/utils'
 import { createTorrentAndSetInfoHash, downloadWebTorrentVideo } from '../../../helpers/webtorrent'
-import { downloadYoutubeDLVideo } from '../../../helpers/youtube-dl'
 import { CONFIG } from '../../../initializers/config'
 import { VIDEO_IMPORT_TIMEOUT } from '../../../initializers/constants'
 import { sequelizeTypescript } from '../../../initializers/database'
@@ -75,8 +76,10 @@ async function processYoutubeDLImport (job: Bull.Job, payload: VideoImportYoutub
    videoImportId: videoImport.id
  }
+  const youtubeDL = new YoutubeDL(videoImport.targetUrl, ServerConfigManager.Instance.getEnabledResolutions('vod'))
  return processFile(
-    () => downloadYoutubeDLVideo(videoImport.targetUrl, payload.fileExt, VIDEO_IMPORT_TIMEOUT),
+    () => youtubeDL.downloadYoutubeDLVideo(payload.fileExt, VIDEO_IMPORT_TIMEOUT),
    videoImport,
    options
  )
@@ -116,7 +119,7 @@ async function processFile (downloader: () => Promise<string>, videoImport: MVid
    const duration = await getDurationFromVideoFile(tempVideoPath)
    // Prepare video file object for creation in database
-    const fileExt = extname(tempVideoPath)
+    const fileExt = getLowercaseExtension(tempVideoPath)
    const videoFileData = {
      extname: fileExt,
      resolution: videoFileResolution,
diff --git a/server/lib/job-queue/handlers/video-live-ending.ts b/server/lib/job-queue/handlers/video-live-ending.ts
index d57202ca5..9eba41bf8 100644
--- a/server/lib/job-queue/handlers/video-live-ending.ts
+++ b/server/lib/job-queue/handlers/video-live-ending.ts
@@ -3,16 +3,16 @@ import { pathExists, readdir, remove } from 'fs-extra'
 import { join } from 'path'
 import { ffprobePromise, getAudioStream, getDurationFromVideoFile, getVideoFileResolution } from '@server/helpers/ffprobe-utils'
 import { VIDEO_LIVE } from '@server/initializers/constants'
-import { LiveManager } from '@server/lib/live-manager'
+import { buildConcatenatedName, cleanupLive, LiveSegmentShaStore } from '@server/lib/live'
 import { generateVideoMiniature } from '@server/lib/thumbnail'
+import { generateHlsPlaylistResolutionFromTS } from '@server/lib/transcoding/video-transcoding'
 import { publishAndFederateIfNeeded } from '@server/lib/video'
 import { getHLSDirectory } from '@server/lib/video-paths'
-import { generateHlsPlaylistResolutionFromTS } from '@server/lib/video-transcoding'
 import { VideoModel } from '@server/models/video/video'
 import { VideoFileModel } from '@server/models/video/video-file'
 import { VideoLiveModel } from '@server/models/video/video-live'
 import { VideoStreamingPlaylistModel } from '@server/models/video/video-streaming-playlist'
-import { MStreamingPlaylist, MVideo, MVideoLive } from '@server/types/models'
+import { MVideo, MVideoLive } from '@server/types/models'
 import { ThumbnailType, VideoLiveEndingPayload, VideoState } from '@shared/models'
 import { logger } from '../../../helpers/logger'
@@ -37,7 +37,7 @@ async function processVideoLiveEnding (job: Bull.Job) {
    return
  }
-  LiveManager.Instance.cleanupShaSegments(video.uuid)
+  LiveSegmentShaStore.Instance.cleanupShaSegments(video.uuid)
  if (live.saveReplay !== true) {
    return cleanupLive(video, streamingPlaylist)
@@ -46,19 +46,10 @@ async function processVideoLiveEnding (job: Bull.Job) {
  return saveLive(video, live)
 }
-async function cleanupLive (video: MVideo, streamingPlaylist: MStreamingPlaylist) {
-  const hlsDirectory = getHLSDirectory(video)
-  await remove(hlsDirectory)
-  await streamingPlaylist.destroy()
-}
 // ---------------------------------------------------------------------------
 export {
-  processVideoLiveEnding,
+  processVideoLiveEnding
-  cleanupLive
 }
 // ---------------------------------------------------------------------------
@@ -94,7 +85,7 @@ async function saveLive (video: MVideo, live: MVideoLive) {
  let durationDone = false
  for (const playlistFile of playlistFiles) {
-    const concatenatedTsFile = LiveManager.Instance.buildConcatenatedName(playlistFile)
+    const concatenatedTsFile = buildConcatenatedName(playlistFile)
    const concatenatedTsFilePath = join(replayDirectory, concatenatedTsFile)
    const probe = await ffprobePromise(concatenatedTsFilePath)
diff --git a/server/lib/job-queue/handlers/video-transcoding.ts b/server/lib/job-queue/handlers/video-transcoding.ts
index 010b95b05..f5ba6f435 100644
--- a/server/lib/job-queue/handlers/video-transcoding.ts
+++ b/server/lib/job-queue/handlers/video-transcoding.ts
@@ -2,7 +2,7 @@ import * as Bull from 'bull'
 import { TranscodeOptionsType } from '@server/helpers/ffmpeg-utils'
 import { getTranscodingJobPriority, publishAndFederateIfNeeded } from '@server/lib/video'
 import { getVideoFilePath } from '@server/lib/video-paths'
-import { UserModel } from '@server/models/account/user'
+import { UserModel } from '@server/models/user/user'
 import { MUser, MUserId, MVideoFullLight, MVideoUUID, MVideoWithFile } from '@server/types/models'
 import {
  HLSTranscodingPayload,
@@ -15,7 +15,6 @@ import { retryTransactionWrapper } from '../../../helpers/database-utils'
 import { computeResolutionsToTranscode } from '../../../helpers/ffprobe-utils'
 import { logger } from '../../../helpers/logger'
 import { CONFIG } from '../../../initializers/config'
-import { sequelizeTypescript } from '../../../initializers/database'
 import { VideoModel } from '../../../models/video/video'
 import { federateVideoIfNeeded } from '../../activitypub/videos'
 import { Notifier } from '../../notifier'
@@ -24,7 +23,7 @@ import {
  mergeAudioVideofile,
  optimizeOriginalVideofile,
  transcodeNewWebTorrentResolution
-} from '../../video-transcoding'
+} from '../../transcoding/video-transcoding'
 import { JobQueue } from '../job-queue'
 type HandlerFunction = (job: Bull.Job, payload: VideoTranscodingPayload, video: MVideoFullLight, user: MUser) => Promise<any>
@@ -151,35 +150,31 @@ async function onVideoFileOptimizer (
  // Outside the transaction (IO on disk)
  const { videoFileResolution, isPortraitMode } = await videoArg.getMaxQualityResolution()
-  const { videoDatabase, videoPublished } = await sequelizeTypescript.transaction(async t => {
+  // Maybe the video changed in database, refresh it
-    // Maybe the video changed in database, refresh it
+  const videoDatabase = await VideoModel.loadAndPopulateAccountAndServerAndTags(videoArg.uuid)
-    const videoDatabase = await VideoModel.loadAndPopulateAccountAndServerAndTags(videoArg.uuid, t)
+  // Video does not exist anymore
-    // Video does not exist anymore
+  if (!videoDatabase) return undefined
-    if (!videoDatabase) return undefined
-    let videoPublished = false
-    // Generate HLS version of the original file
-    const originalFileHLSPayload = Object.assign({}, payload, {
-      isPortraitMode,
-      resolution: videoDatabase.getMaxQualityFile().resolution,
-      // If we quick transcoded original file, force transcoding for HLS to avoid some weird playback issues
-      copyCodecs: transcodeType !== 'quick-transcode',
-      isMaxQuality: true
-    })
-    const hasHls = await createHlsJobIfEnabled(user, originalFileHLSPayload)
-    const hasNewResolutions = await createLowerResolutionsJobs(videoDatabase, user, videoFileResolution, isPortraitMode, 'webtorrent')
-    if (!hasHls && !hasNewResolutions) {
-      // No transcoding to do, it's now published
-      videoPublished = await videoDatabase.publishIfNeededAndSave(t)
-    }
-    await federateVideoIfNeeded(videoDatabase, payload.isNewVideo, t)
+  let videoPublished = false
-    return { videoDatabase, videoPublished }
+  // Generate HLS version of the original file
+  const originalFileHLSPayload = Object.assign({}, payload, {
+    isPortraitMode,
+    resolution: videoDatabase.getMaxQualityFile().resolution,
+    // If we quick transcoded original file, force transcoding for HLS to avoid some weird playback issues
+    copyCodecs: transcodeType !== 'quick-transcode',
+    isMaxQuality: true
  })
+  const hasHls = await createHlsJobIfEnabled(user, originalFileHLSPayload)
+  const hasNewResolutions = await createLowerResolutionsJobs(videoDatabase, user, videoFileResolution, isPortraitMode, 'webtorrent')
+  if (!hasHls && !hasNewResolutions) {
+    // No transcoding to do, it's now published
+    videoPublished = await videoDatabase.publishIfNeededAndSave(undefined)
+  }
+  await federateVideoIfNeeded(videoDatabase, payload.isNewVideo)
  if (payload.isNewVideo) Notifier.Instance.notifyOnNewVideoIfNeeded(videoDatabase)
  if (videoPublished) Notifier.Instance.notifyOnVideoPublishedAfterTranscoding(videoDatabase)
diff --git a/server/lib/job-queue/handlers/video-views.ts b/server/lib/job-queue/handlers/video-views.ts
index 897235ec0..86d0a271f 100644
--- a/server/lib/job-queue/handlers/video-views.ts
+++ b/server/lib/job-queue/handlers/video-views.ts
@@ -36,8 +36,8 @@ async function processVideosViews () {
          }
          await VideoViewModel.create({
-            startDate,
+            startDate: new Date(startDate),
-            endDate,
+            endDate: new Date(endDate),
            views,
            videoId
          })
diff --git a/server/lib/live-manager.ts b/server/lib/live-manager.ts
deleted file mode 100644
index 66b5d119b..000000000
--- a/server/lib/live-manager.ts
+++ /dev/null
@@ -1,621 +0,0 @@
-import * as Bluebird from 'bluebird'
-import * as chokidar from 'chokidar'
-import { FfmpegCommand } from 'fluent-ffmpeg'
-import { appendFile, ensureDir, readFile, stat } from 'fs-extra'
-import { createServer, Server } from 'net'
-import { basename, join } from 'path'
-import { isTestInstance } from '@server/helpers/core-utils'
-import { getLiveMuxingCommand, getLiveTranscodingCommand } from '@server/helpers/ffmpeg-utils'
-import { computeResolutionsToTranscode, getVideoFileFPS, getVideoFileResolution } from '@server/helpers/ffprobe-utils'
-import { logger } from '@server/helpers/logger'
-import { CONFIG, registerConfigChangedHandler } from '@server/initializers/config'
-import { MEMOIZE_TTL, P2P_MEDIA_LOADER_PEER_VERSION, VIDEO_LIVE, VIEW_LIFETIME, WEBSERVER } from '@server/initializers/constants'
-import { UserModel } from '@server/models/account/user'
-import { VideoModel } from '@server/models/video/video'
-import { VideoFileModel } from '@server/models/video/video-file'
-import { VideoLiveModel } from '@server/models/video/video-live'
-import { VideoStreamingPlaylistModel } from '@server/models/video/video-streaming-playlist'
-import { MStreamingPlaylist, MStreamingPlaylistVideo, MUserId, MVideoLive, MVideoLiveVideo } from '@server/types/models'
-import { VideoState, VideoStreamingPlaylistType } from '@shared/models'
-import { federateVideoIfNeeded } from './activitypub/videos'
-import { buildSha256Segment } from './hls'
-import { JobQueue } from './job-queue'
-import { cleanupLive } from './job-queue/handlers/video-live-ending'
-import { PeerTubeSocket } from './peertube-socket'
-import { isAbleToUploadVideo } from './user'
-import { getHLSDirectory } from './video-paths'
-import { VideoTranscodingProfilesManager } from './video-transcoding-profiles'
-import memoizee = require('memoizee')
-const NodeRtmpSession = require('node-media-server/node_rtmp_session')
-const context = require('node-media-server/node_core_ctx')
-const nodeMediaServerLogger = require('node-media-server/node_core_logger')
-// Disable node media server logs
-nodeMediaServerLogger.setLogType(0)
-const config = {
-  rtmp: {
-    port: CONFIG.LIVE.RTMP.PORT,
-    chunk_size: VIDEO_LIVE.RTMP.CHUNK_SIZE,
-    gop_cache: VIDEO_LIVE.RTMP.GOP_CACHE,
-    ping: VIDEO_LIVE.RTMP.PING,
-    ping_timeout: VIDEO_LIVE.RTMP.PING_TIMEOUT
-  },
-  transcoding: {
-    ffmpeg: 'ffmpeg'
-  }
-}
-class LiveManager {
-  private static instance: LiveManager
-  private readonly transSessions = new Map<string, FfmpegCommand>()
-  private readonly videoSessions = new Map<number, string>()
-  // Values are Date().getTime()
-  private readonly watchersPerVideo = new Map<number, number[]>()
-  private readonly segmentsSha256 = new Map<string, Map<string, string>>()
-  private readonly livesPerUser = new Map<number, { liveId: number, videoId: number, size: number }[]>()
-  private readonly isAbleToUploadVideoWithCache = memoizee((userId: number) => {
-    return isAbleToUploadVideo(userId, 1000)
-  }, { maxAge: MEMOIZE_TTL.LIVE_ABLE_TO_UPLOAD })
-  private readonly hasClientSocketsInBadHealthWithCache = memoizee((sessionId: string) => {
-    return this.hasClientSocketsInBadHealth(sessionId)
-  }, { maxAge: MEMOIZE_TTL.LIVE_CHECK_SOCKET_HEALTH })
-  private rtmpServer: Server
-  private constructor () {
-  }
-  init () {
-    const events = this.getContext().nodeEvent
-    events.on('postPublish', (sessionId: string, streamPath: string) => {
-      logger.debug('RTMP received stream', { id: sessionId, streamPath })
-      const splittedPath = streamPath.split('/')
-      if (splittedPath.length !== 3 || splittedPath[1] !== VIDEO_LIVE.RTMP.BASE_PATH) {
-        logger.warn('Live path is incorrect.', { streamPath })
-        return this.abortSession(sessionId)
-      }
-      this.handleSession(sessionId, streamPath, splittedPath[2])
-        .catch(err => logger.error('Cannot handle sessions.', { err }))
-    })
-    events.on('donePublish', sessionId => {
-      logger.info('Live session ended.', { sessionId })
-    })
-    registerConfigChangedHandler(() => {
-      if (!this.rtmpServer && CONFIG.LIVE.ENABLED === true) {
-        this.run()
-        return
-      }
-      if (this.rtmpServer && CONFIG.LIVE.ENABLED === false) {
-        this.stop()
-      }
-    })
-    // Cleanup broken lives, that were terminated by a server restart for example
-    this.handleBrokenLives()
-      .catch(err => logger.error('Cannot handle broken lives.', { err }))
-    setInterval(() => this.updateLiveViews(), VIEW_LIFETIME.LIVE)
-  }
-  run () {
-    logger.info('Running RTMP server on port %d', config.rtmp.port)
-    this.rtmpServer = createServer(socket => {
-      const session = new NodeRtmpSession(config, socket)
-      session.run()
-    })
-    this.rtmpServer.on('error', err => {
-      logger.error('Cannot run RTMP server.', { err })
-    })
-    this.rtmpServer.listen(CONFIG.LIVE.RTMP.PORT)
-  }
-  stop () {
-    logger.info('Stopping RTMP server.')
-    this.rtmpServer.close()
-    this.rtmpServer = undefined
-    // Sessions is an object
-    this.getContext().sessions.forEach((session: any) => {
-      if (session instanceof NodeRtmpSession) {
-        session.stop()
-      }
-    })
-  }
-  isRunning () {
-    return !!this.rtmpServer
-  }
-  getSegmentsSha256 (videoUUID: string) {
-    return this.segmentsSha256.get(videoUUID)
-  }
-  stopSessionOf (videoId: number) {
-    const sessionId = this.videoSessions.get(videoId)
-    if (!sessionId) return
-    this.videoSessions.delete(videoId)
-    this.abortSession(sessionId)
-  }
-  getLiveQuotaUsedByUser (userId: number) {
-    const currentLives = this.livesPerUser.get(userId)
-    if (!currentLives) return 0
-    return currentLives.reduce((sum, obj) => sum + obj.size, 0)
-  }
-  addViewTo (videoId: number) {
-    if (this.videoSessions.has(videoId) === false) return
-    let watchers = this.watchersPerVideo.get(videoId)
-    if (!watchers) {
-      watchers = []
-      this.watchersPerVideo.set(videoId, watchers)
-    }
-    watchers.push(new Date().getTime())
-  }
-  cleanupShaSegments (videoUUID: string) {
-    this.segmentsSha256.delete(videoUUID)
-  }
-  addSegmentToReplay (hlsVideoPath: string, segmentPath: string) {
-    const segmentName = basename(segmentPath)
-    const dest = join(hlsVideoPath, VIDEO_LIVE.REPLAY_DIRECTORY, this.buildConcatenatedName(segmentName))
-    return readFile(segmentPath)
-      .then(data => appendFile(dest, data))
-      .catch(err => logger.error('Cannot copy segment %s to repay directory.', segmentPath, { err }))
-  }
-  buildConcatenatedName (segmentOrPlaylistPath: string) {
-    const num = basename(segmentOrPlaylistPath).match(/^(\d+)(-|\.)/)
-    return 'concat-' + num[1] + '.ts'
-  }
-  private processSegments (hlsVideoPath: string, videoUUID: string, videoLive: MVideoLive, segmentPaths: string[]) {
-    Bluebird.mapSeries(segmentPaths, async previousSegment => {
-      // Add sha hash of previous segments, because ffmpeg should have finished generating them
-      await this.addSegmentSha(videoUUID, previousSegment)
-      if (videoLive.saveReplay) {
-        await this.addSegmentToReplay(hlsVideoPath, previousSegment)
-      }
-    }).catch(err => logger.error('Cannot process segments in %s', hlsVideoPath, { err }))
-  }
-  private getContext () {
-    return context
-  }
-  private abortSession (id: string) {
-    const session = this.getContext().sessions.get(id)
-    if (session) {
-      session.stop()
-      this.getContext().sessions.delete(id)
-    }
-    const transSession = this.transSessions.get(id)
-    if (transSession) {
-      transSession.kill('SIGINT')
-      this.transSessions.delete(id)
-    }
-  }
-  private async handleSession (sessionId: string, streamPath: string, streamKey: string) {
-    const videoLive = await VideoLiveModel.loadByStreamKey(streamKey)
-    if (!videoLive) {
-      logger.warn('Unknown live video with stream key %s.', streamKey)
-      return this.abortSession(sessionId)
-    }
-    const video = videoLive.Video
-    if (video.isBlacklisted()) {
-      logger.warn('Video is blacklisted. Refusing stream %s.', streamKey)
-      return this.abortSession(sessionId)
-    }
-    // Cleanup old potential live files (could happen with a permanent live)
-    this.cleanupShaSegments(video.uuid)
-    const oldStreamingPlaylist = await VideoStreamingPlaylistModel.loadHLSPlaylistByVideo(video.id)
-    if (oldStreamingPlaylist) {
-      await cleanupLive(video, oldStreamingPlaylist)
-    }
-    this.videoSessions.set(video.id, sessionId)
-    const playlistUrl = WEBSERVER.URL + VideoStreamingPlaylistModel.getHlsMasterPlaylistStaticPath(video.uuid)
-    const session = this.getContext().sessions.get(sessionId)
-    const rtmpUrl = 'rtmp://127.0.0.1:' + config.rtmp.port + streamPath
-    const [ resolutionResult, fps ] = await Promise.all([
-      getVideoFileResolution(rtmpUrl),
-      getVideoFileFPS(rtmpUrl)
-    ])
-    const resolutionsEnabled = CONFIG.LIVE.TRANSCODING.ENABLED
-      ? computeResolutionsToTranscode(resolutionResult.videoFileResolution, 'live')
-      : []
-    const allResolutions = resolutionsEnabled.concat([ session.videoHeight ])
-    logger.info('Will mux/transcode live video of original resolution %d.', session.videoHeight, { allResolutions })
-    const [ videoStreamingPlaylist ] = await VideoStreamingPlaylistModel.upsert({
-      videoId: video.id,
-      playlistUrl,
-      segmentsSha256Url: WEBSERVER.URL + VideoStreamingPlaylistModel.getHlsSha256SegmentsStaticPath(video.uuid, video.isLive),
-      p2pMediaLoaderInfohashes: VideoStreamingPlaylistModel.buildP2PMediaLoaderInfoHashes(playlistUrl, allResolutions),
-      p2pMediaLoaderPeerVersion: P2P_MEDIA_LOADER_PEER_VERSION,
-      type: VideoStreamingPlaylistType.HLS
-    }, { returning: true }) as [ MStreamingPlaylist, boolean ]
-    return this.runMuxing({
-      sessionId,
-      videoLive,
-      playlist: Object.assign(videoStreamingPlaylist, { Video: video }),
-      rtmpUrl,
-      fps,
-      allResolutions
-    })
-  }
-  private async runMuxing (options: {
-    sessionId: string
-    videoLive: MVideoLiveVideo
-    playlist: MStreamingPlaylistVideo
-    rtmpUrl: string
-    fps: number
-    allResolutions: number[]
-  }) {
-    const { sessionId, videoLive, playlist, allResolutions, fps, rtmpUrl } = options
-    const startStreamDateTime = new Date().getTime()
-    const user = await UserModel.loadByLiveId(videoLive.id)
-    if (!this.livesPerUser.has(user.id)) {
-      this.livesPerUser.set(user.id, [])
-    }
-    const currentUserLive = { liveId: videoLive.id, videoId: videoLive.videoId, size: 0 }
-    const livesOfUser = this.livesPerUser.get(user.id)
-    livesOfUser.push(currentUserLive)
-    for (let i = 0; i < allResolutions.length; i++) {
-      const resolution = allResolutions[i]
-      const file = new VideoFileModel({
-        resolution,
-        size: -1,
-        extname: '.ts',
-        infoHash: null,
-        fps,
-        videoStreamingPlaylistId: playlist.id
-      })
-      VideoFileModel.customUpsert(file, 'streaming-playlist', null)
-        .catch(err => logger.error('Cannot create file for live streaming.', { err }))
-    }
-    const outPath = getHLSDirectory(videoLive.Video)
-    await ensureDir(outPath)
-    const replayDirectory = join(outPath, VIDEO_LIVE.REPLAY_DIRECTORY)
-    if (videoLive.saveReplay === true) {
-      await ensureDir(replayDirectory)
-    }
-    const videoUUID = videoLive.Video.uuid
-    const ffmpegExec = CONFIG.LIVE.TRANSCODING.ENABLED
-      ? await getLiveTranscodingCommand({
-        rtmpUrl,
-        outPath,
-        resolutions: allResolutions,
-        fps,
-        availableEncoders: VideoTranscodingProfilesManager.Instance.getAvailableEncoders(),
-        profile: CONFIG.LIVE.TRANSCODING.PROFILE
-      })
-      : getLiveMuxingCommand(rtmpUrl, outPath)
-    logger.info('Running live muxing/transcoding for %s.', videoUUID)
-    this.transSessions.set(sessionId, ffmpegExec)
-    const tsWatcher = chokidar.watch(outPath + '/*.ts')
-    const segmentsToProcessPerPlaylist: { [playlistId: string]: string[] } = {}
-    const playlistIdMatcher = /^([\d+])-/
-    const addHandler = segmentPath => {
-      logger.debug('Live add handler of %s.', segmentPath)
-      const playlistId = basename(segmentPath).match(playlistIdMatcher)[0]
-      const segmentsToProcess = segmentsToProcessPerPlaylist[playlistId] || []
-      this.processSegments(outPath, videoUUID, videoLive, segmentsToProcess)
-      segmentsToProcessPerPlaylist[playlistId] = [ segmentPath ]
-      if (this.hasClientSocketsInBadHealthWithCache(sessionId)) {
-        logger.error(
-          'Too much data in client socket stream (ffmpeg is too slow to transcode the video).' +
-          ' Stopping session of video %s.', videoUUID)
-        this.stopSessionOf(videoLive.videoId)
-        return
-      }
-      // Duration constraint check
-      if (this.isDurationConstraintValid(startStreamDateTime) !== true) {
-        logger.info('Stopping session of %s: max duration exceeded.', videoUUID)
-        this.stopSessionOf(videoLive.videoId)
-        return
-      }
-      // Check user quota if the user enabled replay saving
-      if (videoLive.saveReplay === true) {
-        stat(segmentPath)
-          .then(segmentStat => {
-            currentUserLive.size += segmentStat.size
-          })
-          .then(() => this.isQuotaConstraintValid(user, videoLive))
-          .then(quotaValid => {
-            if (quotaValid !== true) {
-              logger.info('Stopping session of %s: user quota exceeded.', videoUUID)
-              this.stopSessionOf(videoLive.videoId)
-            }
-          })
-          .catch(err => logger.error('Cannot stat %s or check quota of %d.', segmentPath, user.id, { err }))
-      }
-    }
-    const deleteHandler = segmentPath => this.removeSegmentSha(videoUUID, segmentPath)
-    tsWatcher.on('add', p => addHandler(p))
-    tsWatcher.on('unlink', p => deleteHandler(p))
-    const masterWatcher = chokidar.watch(outPath + '/master.m3u8')
-    masterWatcher.on('add', async () => {
-      try {
-        const video = await VideoModel.loadAndPopulateAccountAndServerAndTags(videoLive.videoId)
-        video.state = VideoState.PUBLISHED
-        await video.save()
-        videoLive.Video = video
-        setTimeout(() => {
-          federateVideoIfNeeded(video, false)
-            .catch(err => logger.error('Cannot federate live video %s.', video.url, { err }))
-          PeerTubeSocket.Instance.sendVideoLiveNewState(video)
-        }, VIDEO_LIVE.SEGMENT_TIME_SECONDS * 1000 * VIDEO_LIVE.EDGE_LIVE_DELAY_SEGMENTS_NOTIFICATION)
-      } catch (err) {
-        logger.error('Cannot save/federate live video %d.', videoLive.videoId, { err })
-      } finally {
-        masterWatcher.close()
-          .catch(err => logger.error('Cannot close master watcher of %s.', outPath, { err }))
-      }
-    })
-    const onFFmpegEnded = () => {
-      logger.info('RTMP transmuxing for video %s ended. Scheduling cleanup', rtmpUrl)
-      this.transSessions.delete(sessionId)
-      this.watchersPerVideo.delete(videoLive.videoId)
-      this.videoSessions.delete(videoLive.videoId)
-      const newLivesPerUser = this.livesPerUser.get(user.id)
-                                               .filter(o => o.liveId !== videoLive.id)
-      this.livesPerUser.set(user.id, newLivesPerUser)
-      setTimeout(() => {
-        // Wait latest segments generation, and close watchers
-        Promise.all([ tsWatcher.close(), masterWatcher.close() ])
-          .then(() => {
-            // Process remaining segments hash
-            for (const key of Object.keys(segmentsToProcessPerPlaylist)) {
-              this.processSegments(outPath, videoUUID, videoLive, segmentsToProcessPerPlaylist[key])
-            }
-          })
-          .catch(err => logger.error('Cannot close watchers of %s or process remaining hash segments.', outPath, { err }))
-        this.onEndTransmuxing(videoLive.Video.id)
-          .catch(err => logger.error('Error in closed transmuxing.', { err }))
-      }, 1000)
-    }
-    ffmpegExec.on('error', (err, stdout, stderr) => {
-      onFFmpegEnded()
-      // Don't care that we killed the ffmpeg process
-      if (err?.message?.includes('Exiting normally')) return
-      logger.error('Live transcoding error.', { err, stdout, stderr })
-      this.abortSession(sessionId)
-    })
-    ffmpegExec.on('end', () => onFFmpegEnded())
-    ffmpegExec.run()
-  }
-  private async onEndTransmuxing (videoId: number, cleanupNow = false) {
-    try {
-      const fullVideo = await VideoModel.loadAndPopulateAccountAndServerAndTags(videoId)
-      if (!fullVideo) return
-      const live = await VideoLiveModel.loadByVideoId(videoId)
-      if (!live.permanentLive) {
-        JobQueue.Instance.createJob({
-          type: 'video-live-ending',
-          payload: {
-            videoId: fullVideo.id
-          }
-        }, { delay: cleanupNow ? 0 : VIDEO_LIVE.CLEANUP_DELAY })
-        fullVideo.state = VideoState.LIVE_ENDED
-      } else {
-        fullVideo.state = VideoState.WAITING_FOR_LIVE
-      }
-      await fullVideo.save()
-      PeerTubeSocket.Instance.sendVideoLiveNewState(fullVideo)
-      await federateVideoIfNeeded(fullVideo, false)
-    } catch (err) {
-      logger.error('Cannot save/federate new video state of live streaming of video id %d.', videoId, { err })
-    }
-  }
-  private async addSegmentSha (videoUUID: string, segmentPath: string) {
-    const segmentName = basename(segmentPath)
-    logger.debug('Adding live sha segment %s.', segmentPath)
-    const shaResult = await buildSha256Segment(segmentPath)
-    if (!this.segmentsSha256.has(videoUUID)) {
-      this.segmentsSha256.set(videoUUID, new Map())
-    }
-    const filesMap = this.segmentsSha256.get(videoUUID)
-    filesMap.set(segmentName, shaResult)
-  }
-  private removeSegmentSha (videoUUID: string, segmentPath: string) {
-    const segmentName = basename(segmentPath)
-    logger.debug('Removing live sha segment %s.', segmentPath)
-    const filesMap = this.segmentsSha256.get(videoUUID)
-    if (!filesMap) {
-      logger.warn('Unknown files map to remove sha for %s.', videoUUID)
-      return
-    }
-    if (!filesMap.has(segmentName)) {
-      logger.warn('Unknown segment in files map for video %s and segment %s.', videoUUID, segmentPath)
-      return
-    }
-    filesMap.delete(segmentName)
-  }
-  private isDurationConstraintValid (streamingStartTime: number) {
-    const maxDuration = CONFIG.LIVE.MAX_DURATION
-    // No limit
-    if (maxDuration < 0) return true
-    const now = new Date().getTime()
-    const max = streamingStartTime + maxDuration
-    return now <= max
-  }
-  private hasClientSocketsInBadHealth (sessionId: string) {
-    const rtmpSession = this.getContext().sessions.get(sessionId)
-    if (!rtmpSession) {
-      logger.warn('Cannot get session %s to check players socket health.', sessionId)
-      return
-    }
-    for (const playerSessionId of rtmpSession.players) {
-      const playerSession = this.getContext().sessions.get(playerSessionId)
-      if (!playerSession) {
-        logger.error('Cannot get player session %s to check socket health.', playerSession)
-        continue
-      }
-      if (playerSession.socket.writableLength > VIDEO_LIVE.MAX_SOCKET_WAITING_DATA) {
-        return true
-      }
-    }
-    return false
-  }
-  private async isQuotaConstraintValid (user: MUserId, live: MVideoLive) {
-    if (live.saveReplay !== true) return true
-    return this.isAbleToUploadVideoWithCache(user.id)
-  }
-  private async updateLiveViews () {
-    if (!this.isRunning()) return
-    if (!isTestInstance()) logger.info('Updating live video views.')
-    for (const videoId of this.watchersPerVideo.keys()) {
-      const notBefore = new Date().getTime() - VIEW_LIFETIME.LIVE
-      const watchers = this.watchersPerVideo.get(videoId)
-      const numWatchers = watchers.length
-      const video = await VideoModel.loadAndPopulateAccountAndServerAndTags(videoId)
-      video.views = numWatchers
-      await video.save()
-      await federateVideoIfNeeded(video, false)
-      PeerTubeSocket.Instance.sendVideoViewsUpdate(video)
-      // Only keep not expired watchers
-      const newWatchers = watchers.filter(w => w > notBefore)
-      this.watchersPerVideo.set(videoId, newWatchers)
-      logger.debug('New live video views for %s is %d.', video.url, numWatchers)
-    }
-  }
-  private async handleBrokenLives () {
-    const videoIds = await VideoModel.listPublishedLiveIds()
-    for (const id of videoIds) {
-      await this.onEndTransmuxing(id, true)
-    }
-  }
-  static get Instance () {
-    return this.instance || (this.instance = new this())
-  }
-}
-// ---------------------------------------------------------------------------
-export {
-  LiveManager
-}
diff --git a/server/lib/live/index.ts b/server/lib/live/index.ts
new file mode 100644
index 000000000..8b46800da
--- /dev/null
+++ b/server/lib/live/index.ts
@@ -0,0 +1,4 @@
+export * from './live-manager'
+export * from './live-quota-store'
+export * from './live-segment-sha-store'
+export * from './live-utils'
diff --git a/server/lib/live/live-manager.ts b/server/lib/live/live-manager.ts
new file mode 100644
index 000000000..014cd3fcf
--- /dev/null
+++ b/server/lib/live/live-manager.ts
@@ -0,0 +1,419 @@
+import { createServer, Server } from 'net'
+import { isTestInstance } from '@server/helpers/core-utils'
+import { computeResolutionsToTranscode, getVideoFileFPS, getVideoFileResolution } from '@server/helpers/ffprobe-utils'
+import { logger, loggerTagsFactory } from '@server/helpers/logger'
+import { CONFIG, registerConfigChangedHandler } from '@server/initializers/config'
+import { P2P_MEDIA_LOADER_PEER_VERSION, VIDEO_LIVE, VIEW_LIFETIME, WEBSERVER } from '@server/initializers/constants'
+import { UserModel } from '@server/models/user/user'
+import { VideoModel } from '@server/models/video/video'
+import { VideoLiveModel } from '@server/models/video/video-live'
+import { VideoStreamingPlaylistModel } from '@server/models/video/video-streaming-playlist'
+import { MStreamingPlaylist, MStreamingPlaylistVideo, MVideo, MVideoLiveVideo } from '@server/types/models'
+import { VideoState, VideoStreamingPlaylistType } from '@shared/models'
+import { federateVideoIfNeeded } from '../activitypub/videos'
+import { JobQueue } from '../job-queue'
+import { PeerTubeSocket } from '../peertube-socket'
+import { LiveQuotaStore } from './live-quota-store'
+import { LiveSegmentShaStore } from './live-segment-sha-store'
+import { cleanupLive } from './live-utils'
+import { MuxingSession } from './shared'
+const NodeRtmpSession = require('node-media-server/node_rtmp_session')
+const context = require('node-media-server/node_core_ctx')
+const nodeMediaServerLogger = require('node-media-server/node_core_logger')
+// Disable node media server logs
+nodeMediaServerLogger.setLogType(0)
+const config = {
+  rtmp: {
+    port: CONFIG.LIVE.RTMP.PORT,
+    chunk_size: VIDEO_LIVE.RTMP.CHUNK_SIZE,
+    gop_cache: VIDEO_LIVE.RTMP.GOP_CACHE,
+    ping: VIDEO_LIVE.RTMP.PING,
+    ping_timeout: VIDEO_LIVE.RTMP.PING_TIMEOUT
+  },
+  transcoding: {
+    ffmpeg: 'ffmpeg'
+  }
+}
+const lTags = loggerTagsFactory('live')
+class LiveManager {
+  private static instance: LiveManager
+  private readonly muxingSessions = new Map<string, MuxingSession>()
+  private readonly videoSessions = new Map<number, string>()
+  // Values are Date().getTime()
+  private readonly watchersPerVideo = new Map<number, number[]>()
+  private rtmpServer: Server
+  private constructor () {
+  }
+  init () {
+    const events = this.getContext().nodeEvent
+    events.on('postPublish', (sessionId: string, streamPath: string) => {
+      logger.debug('RTMP received stream', { id: sessionId, streamPath, ...lTags(sessionId) })
+      const splittedPath = streamPath.split('/')
+      if (splittedPath.length !== 3 || splittedPath[1] !== VIDEO_LIVE.RTMP.BASE_PATH) {
+        logger.warn('Live path is incorrect.', { streamPath, ...lTags(sessionId) })
+        return this.abortSession(sessionId)
+      }
+      this.handleSession(sessionId, streamPath, splittedPath[2])
+        .catch(err => logger.error('Cannot handle sessions.', { err, ...lTags(sessionId) }))
+    })
+    events.on('donePublish', sessionId => {
+      logger.info('Live session ended.', { sessionId, ...lTags(sessionId) })
+    })
+    registerConfigChangedHandler(() => {
+      if (!this.rtmpServer && CONFIG.LIVE.ENABLED === true) {
+        this.run()
+        return
+      }
+      if (this.rtmpServer && CONFIG.LIVE.ENABLED === false) {
+        this.stop()
+      }
+    })
+    // Cleanup broken lives, that were terminated by a server restart for example
+    this.handleBrokenLives()
+      .catch(err => logger.error('Cannot handle broken lives.', { err, ...lTags() }))
+    setInterval(() => this.updateLiveViews(), VIEW_LIFETIME.LIVE)
+  }
+  run () {
+    logger.info('Running RTMP server on port %d', config.rtmp.port, lTags())
+    this.rtmpServer = createServer(socket => {
+      const session = new NodeRtmpSession(config, socket)
+      session.run()
+    })
+    this.rtmpServer.on('error', err => {
+      logger.error('Cannot run RTMP server.', { err, ...lTags() })
+    })
+    this.rtmpServer.listen(CONFIG.LIVE.RTMP.PORT)
+  }
+  stop () {
+    logger.info('Stopping RTMP server.', lTags())
+    this.rtmpServer.close()
+    this.rtmpServer = undefined
+    // Sessions is an object
+    this.getContext().sessions.forEach((session: any) => {
+      if (session instanceof NodeRtmpSession) {
+        session.stop()
+      }
+    })
+  }
+  isRunning () {
+    return !!this.rtmpServer
+  }
+  stopSessionOf (videoId: number) {
+    const sessionId = this.videoSessions.get(videoId)
+    if (!sessionId) return
+    this.videoSessions.delete(videoId)
+    this.abortSession(sessionId)
+  }
+  addViewTo (videoId: number) {
+    if (this.videoSessions.has(videoId) === false) return
+    let watchers = this.watchersPerVideo.get(videoId)
+    if (!watchers) {
+      watchers = []
+      this.watchersPerVideo.set(videoId, watchers)
+    }
+    watchers.push(new Date().getTime())
+  }
+  private getContext () {
+    return context
+  }
+  private abortSession (sessionId: string) {
+    const session = this.getContext().sessions.get(sessionId)
+    if (session) {
+      session.stop()
+      this.getContext().sessions.delete(sessionId)
+    }
+    const muxingSession = this.muxingSessions.get(sessionId)
+    if (muxingSession) {
+      // Muxing session will fire and event so we correctly cleanup the session
+      muxingSession.abort()
+      this.muxingSessions.delete(sessionId)
+    }
+  }
+  private async handleSession (sessionId: string, streamPath: string, streamKey: string) {
+    const videoLive = await VideoLiveModel.loadByStreamKey(streamKey)
+    if (!videoLive) {
+      logger.warn('Unknown live video with stream key %s.', streamKey, lTags(sessionId))
+      return this.abortSession(sessionId)
+    }
+    const video = videoLive.Video
+    if (video.isBlacklisted()) {
+      logger.warn('Video is blacklisted. Refusing stream %s.', streamKey, lTags(sessionId, video.uuid))
+      return this.abortSession(sessionId)
+    }
+    // Cleanup old potential live files (could happen with a permanent live)
+    LiveSegmentShaStore.Instance.cleanupShaSegments(video.uuid)
+    const oldStreamingPlaylist = await VideoStreamingPlaylistModel.loadHLSPlaylistByVideo(video.id)
+    if (oldStreamingPlaylist) {
+      await cleanupLive(video, oldStreamingPlaylist)
+    }
+    this.videoSessions.set(video.id, sessionId)
+    const rtmpUrl = 'rtmp://127.0.0.1:' + config.rtmp.port + streamPath
+    const [ { videoFileResolution }, fps ] = await Promise.all([
+      getVideoFileResolution(rtmpUrl),
+      getVideoFileFPS(rtmpUrl)
+    ])
+    const allResolutions = this.buildAllResolutionsToTranscode(videoFileResolution)
+    logger.info(
+      'Will mux/transcode live video of original resolution %d.', videoFileResolution,
+      { allResolutions, ...lTags(sessionId, video.uuid) }
+    )
+    const streamingPlaylist = await this.createLivePlaylist(video, allResolutions)
+    return this.runMuxingSession({
+      sessionId,
+      videoLive,
+      streamingPlaylist,
+      rtmpUrl,
+      fps,
+      allResolutions
+    })
+  }
+  private async runMuxingSession (options: {
+    sessionId: string
+    videoLive: MVideoLiveVideo
+    streamingPlaylist: MStreamingPlaylistVideo
+    rtmpUrl: string
+    fps: number
+    allResolutions: number[]
+  }) {
+    const { sessionId, videoLive, streamingPlaylist, allResolutions, fps, rtmpUrl } = options
+    const videoUUID = videoLive.Video.uuid
+    const localLTags = lTags(sessionId, videoUUID)
+    const user = await UserModel.loadByLiveId(videoLive.id)
+    LiveQuotaStore.Instance.addNewLive(user.id, videoLive.id)
+    const muxingSession = new MuxingSession({
+      context: this.getContext(),
+      user,
+      sessionId,
+      videoLive,
+      streamingPlaylist,
+      rtmpUrl,
+      fps,
+      allResolutions
+    })
+    muxingSession.on('master-playlist-created', () => this.publishAndFederateLive(videoLive, localLTags))
+    muxingSession.on('bad-socket-health', ({ videoId }) => {
+      logger.error(
+        'Too much data in client socket stream (ffmpeg is too slow to transcode the video).' +
+        ' Stopping session of video %s.', videoUUID,
+        localLTags
+      )
+      this.stopSessionOf(videoId)
+    })
+    muxingSession.on('duration-exceeded', ({ videoId }) => {
+      logger.info('Stopping session of %s: max duration exceeded.', videoUUID, localLTags)
+      this.stopSessionOf(videoId)
+    })
+    muxingSession.on('quota-exceeded', ({ videoId }) => {
+      logger.info('Stopping session of %s: user quota exceeded.', videoUUID, localLTags)
+      this.stopSessionOf(videoId)
+    })
+    muxingSession.on('ffmpeg-error', ({ sessionId }) => this.abortSession(sessionId))
+    muxingSession.on('ffmpeg-end', ({ videoId }) => {
+      this.onMuxingFFmpegEnd(videoId)
+    })
+    muxingSession.on('after-cleanup', ({ videoId }) => {
+      this.muxingSessions.delete(sessionId)
+      muxingSession.destroy()
+      return this.onAfterMuxingCleanup(videoId)
+        .catch(err => logger.error('Error in end transmuxing.', { err, ...localLTags }))
+    })
+    this.muxingSessions.set(sessionId, muxingSession)
+    muxingSession.runMuxing()
+      .catch(err => {
+        logger.error('Cannot run muxing.', { err, ...localLTags })
+        this.abortSession(sessionId)
+      })
+  }
+  private async publishAndFederateLive (live: MVideoLiveVideo, localLTags: { tags: string[] }) {
+    const videoId = live.videoId
+    try {
+      const video = await VideoModel.loadAndPopulateAccountAndServerAndTags(videoId)
+      logger.info('Will publish and federate live %s.', video.url, localLTags)
+      video.state = VideoState.PUBLISHED
+      await video.save()
+      live.Video = video
+      setTimeout(() => {
+        federateVideoIfNeeded(video, false)
+          .catch(err => logger.error('Cannot federate live video %s.', video.url, { err, ...localLTags }))
+        PeerTubeSocket.Instance.sendVideoLiveNewState(video)
+      }, VIDEO_LIVE.SEGMENT_TIME_SECONDS * 1000 * VIDEO_LIVE.EDGE_LIVE_DELAY_SEGMENTS_NOTIFICATION)
+    } catch (err) {
+      logger.error('Cannot save/federate live video %d.', videoId, { err, ...localLTags })
+    }
+  }
+  private onMuxingFFmpegEnd (videoId: number) {
+    this.watchersPerVideo.delete(videoId)
+    this.videoSessions.delete(videoId)
+  }
+  private async onAfterMuxingCleanup (videoUUID: string, cleanupNow = false) {
+    try {
+      const fullVideo = await VideoModel.loadAndPopulateAccountAndServerAndTags(videoUUID)
+      if (!fullVideo) return
+      const live = await VideoLiveModel.loadByVideoId(fullVideo.id)
+      if (!live.permanentLive) {
+        JobQueue.Instance.createJob({
+          type: 'video-live-ending',
+          payload: {
+            videoId: fullVideo.id
+          }
+        }, { delay: cleanupNow ? 0 : VIDEO_LIVE.CLEANUP_DELAY })
+        fullVideo.state = VideoState.LIVE_ENDED
+      } else {
+        fullVideo.state = VideoState.WAITING_FOR_LIVE
+      }
+      await fullVideo.save()
+      PeerTubeSocket.Instance.sendVideoLiveNewState(fullVideo)
+      await federateVideoIfNeeded(fullVideo, false)
+    } catch (err) {
+      logger.error('Cannot save/federate new video state of live streaming of video %d.', videoUUID, { err, ...lTags(videoUUID) })
+    }
+  }
+  private async updateLiveViews () {
+    if (!this.isRunning()) return
+    if (!isTestInstance()) logger.info('Updating live video views.', lTags())
+    for (const videoId of this.watchersPerVideo.keys()) {
+      const notBefore = new Date().getTime() - VIEW_LIFETIME.LIVE
+      const watchers = this.watchersPerVideo.get(videoId)
+      const numWatchers = watchers.length
+      const video = await VideoModel.loadAndPopulateAccountAndServerAndTags(videoId)
+      video.views = numWatchers
+      await video.save()
+      await federateVideoIfNeeded(video, false)
+      PeerTubeSocket.Instance.sendVideoViewsUpdate(video)
+      // Only keep not expired watchers
+      const newWatchers = watchers.filter(w => w > notBefore)
+      this.watchersPerVideo.set(videoId, newWatchers)
+      logger.debug('New live video views for %s is %d.', video.url, numWatchers, lTags())
+    }
+  }
+  private async handleBrokenLives () {
+    const videoUUIDs = await VideoModel.listPublishedLiveUUIDs()
+    for (const uuid of videoUUIDs) {
+      await this.onAfterMuxingCleanup(uuid, true)
+    }
+  }
+  private buildAllResolutionsToTranscode (originResolution: number) {
+    const resolutionsEnabled = CONFIG.LIVE.TRANSCODING.ENABLED
+      ? computeResolutionsToTranscode(originResolution, 'live')
+      : []
+    return resolutionsEnabled.concat([ originResolution ])
+  }
+  private async createLivePlaylist (video: MVideo, allResolutions: number[]) {
+    const playlistUrl = WEBSERVER.URL + VideoStreamingPlaylistModel.getHlsMasterPlaylistStaticPath(video.uuid)
+    const [ videoStreamingPlaylist ] = await VideoStreamingPlaylistModel.upsert({
+      videoId: video.id,
+      playlistUrl,
+      segmentsSha256Url: WEBSERVER.URL + VideoStreamingPlaylistModel.getHlsSha256SegmentsStaticPath(video.uuid, video.isLive),
+      p2pMediaLoaderInfohashes: VideoStreamingPlaylistModel.buildP2PMediaLoaderInfoHashes(playlistUrl, allResolutions),
+      p2pMediaLoaderPeerVersion: P2P_MEDIA_LOADER_PEER_VERSION,
+      type: VideoStreamingPlaylistType.HLS
+    }, { returning: true }) as [ MStreamingPlaylist, boolean ]
+    return Object.assign(videoStreamingPlaylist, { Video: video })
+  }
+  static get Instance () {
+    return this.instance || (this.instance = new this())
+  }
+}
+// ---------------------------------------------------------------------------
+export {
+  LiveManager
+}
diff --git a/server/lib/live/live-quota-store.ts b/server/lib/live/live-quota-store.ts
new file mode 100644
index 000000000..8ceccde98
--- /dev/null
+++ b/server/lib/live/live-quota-store.ts
@@ -0,0 +1,48 @@
+class LiveQuotaStore {
+  private static instance: LiveQuotaStore
+  private readonly livesPerUser = new Map<number, { liveId: number, size: number }[]>()
+  private constructor () {
+  }
+  addNewLive (userId: number, liveId: number) {
+    if (!this.livesPerUser.has(userId)) {
+      this.livesPerUser.set(userId, [])
+    }
+    const currentUserLive = { liveId, size: 0 }
+    const livesOfUser = this.livesPerUser.get(userId)
+    livesOfUser.push(currentUserLive)
+  }
+  removeLive (userId: number, liveId: number) {
+    const newLivesPerUser = this.livesPerUser.get(userId)
+                                             .filter(o => o.liveId !== liveId)
+    this.livesPerUser.set(userId, newLivesPerUser)
+  }
+  addQuotaTo (userId: number, liveId: number, size: number) {
+    const lives = this.livesPerUser.get(userId)
+    const live = lives.find(l => l.liveId === liveId)
+    live.size += size
+  }
+  getLiveQuotaOf (userId: number) {
+    const currentLives = this.livesPerUser.get(userId)
+    if (!currentLives) return 0
+    return currentLives.reduce((sum, obj) => sum + obj.size, 0)
+  }
+  static get Instance () {
+    return this.instance || (this.instance = new this())
+  }
+}
+export {
+  LiveQuotaStore
+}
diff --git a/server/lib/live/live-segment-sha-store.ts b/server/lib/live/live-segment-sha-store.ts
new file mode 100644
index 000000000..4af6f3ebf
--- /dev/null
+++ b/server/lib/live/live-segment-sha-store.ts
@@ -0,0 +1,64 @@
+import { basename } from 'path'
+import { logger, loggerTagsFactory } from '@server/helpers/logger'
+import { buildSha256Segment } from '../hls'
+const lTags = loggerTagsFactory('live')
+class LiveSegmentShaStore {
+  private static instance: LiveSegmentShaStore
+  private readonly segmentsSha256 = new Map<string, Map<string, string>>()
+  private constructor () {
+  }
+  getSegmentsSha256 (videoUUID: string) {
+    return this.segmentsSha256.get(videoUUID)
+  }
+  async addSegmentSha (videoUUID: string, segmentPath: string) {
+    const segmentName = basename(segmentPath)
+    logger.debug('Adding live sha segment %s.', segmentPath, lTags(videoUUID))
+    const shaResult = await buildSha256Segment(segmentPath)
+    if (!this.segmentsSha256.has(videoUUID)) {
+      this.segmentsSha256.set(videoUUID, new Map())
+    }
+    const filesMap = this.segmentsSha256.get(videoUUID)
+    filesMap.set(segmentName, shaResult)
+  }
+  removeSegmentSha (videoUUID: string, segmentPath: string) {
+    const segmentName = basename(segmentPath)
+    logger.debug('Removing live sha segment %s.', segmentPath, lTags(videoUUID))
+    const filesMap = this.segmentsSha256.get(videoUUID)
+    if (!filesMap) {
+      logger.warn('Unknown files map to remove sha for %s.', videoUUID, lTags(videoUUID))
+      return
+    }
+    if (!filesMap.has(segmentName)) {
+      logger.warn('Unknown segment in files map for video %s and segment %s.', videoUUID, segmentPath, lTags(videoUUID))
+      return
+    }
+    filesMap.delete(segmentName)
+  }
+  cleanupShaSegments (videoUUID: string) {
+    this.segmentsSha256.delete(videoUUID)
+  }
+  static get Instance () {
+    return this.instance || (this.instance = new this())
+  }
+}
+export {
+  LiveSegmentShaStore
+}
diff --git a/server/lib/live/live-utils.ts b/server/lib/live/live-utils.ts
new file mode 100644
index 000000000..e4526c7a5
--- /dev/null
+++ b/server/lib/live/live-utils.ts
@@ -0,0 +1,23 @@
+import { remove } from 'fs-extra'
+import { basename } from 'path'
+import { MStreamingPlaylist, MVideo } from '@server/types/models'
+import { getHLSDirectory } from '../video-paths'
+function buildConcatenatedName (segmentOrPlaylistPath: string) {
+  const num = basename(segmentOrPlaylistPath).match(/^(\d+)(-|\.)/)
+  return 'concat-' + num[1] + '.ts'
+}
+async function cleanupLive (video: MVideo, streamingPlaylist: MStreamingPlaylist) {
+  const hlsDirectory = getHLSDirectory(video)
+  await remove(hlsDirectory)
+  await streamingPlaylist.destroy()
+}
+export {
+  cleanupLive,
+  buildConcatenatedName
+}
diff --git a/server/lib/live/shared/index.ts b/server/lib/live/shared/index.ts
new file mode 100644
index 000000000..c4d1b59ec
--- /dev/null
+++ b/server/lib/live/shared/index.ts
@@ -0,0 +1 @@
+export * from './muxing-session'
diff --git a/server/lib/live/shared/muxing-session.ts b/server/lib/live/shared/muxing-session.ts
new file mode 100644
index 000000000..26467f060
--- /dev/null
+++ b/server/lib/live/shared/muxing-session.ts
@@ -0,0 +1,346 @@
+import * as Bluebird from 'bluebird'
+import * as chokidar from 'chokidar'
+import { FfmpegCommand } from 'fluent-ffmpeg'
+import { appendFile, ensureDir, readFile, stat } from 'fs-extra'
+import { basename, join } from 'path'
+import { EventEmitter } from 'stream'
+import { getLiveMuxingCommand, getLiveTranscodingCommand } from '@server/helpers/ffmpeg-utils'
+import { logger, loggerTagsFactory, LoggerTagsFn } from '@server/helpers/logger'
+import { CONFIG } from '@server/initializers/config'
+import { MEMOIZE_TTL, VIDEO_LIVE } from '@server/initializers/constants'
+import { VideoFileModel } from '@server/models/video/video-file'
+import { MStreamingPlaylistVideo, MUserId, MVideoLiveVideo } from '@server/types/models'
+import { VideoTranscodingProfilesManager } from '../../transcoding/video-transcoding-profiles'
+import { isAbleToUploadVideo } from '../../user'
+import { getHLSDirectory } from '../../video-paths'
+import { LiveQuotaStore } from '../live-quota-store'
+import { LiveSegmentShaStore } from '../live-segment-sha-store'
+import { buildConcatenatedName } from '../live-utils'
+import memoizee = require('memoizee')
+interface MuxingSessionEvents {
+  'master-playlist-created': ({ videoId: number }) => void
+  'bad-socket-health': ({ videoId: number }) => void
+  'duration-exceeded': ({ videoId: number }) => void
+  'quota-exceeded': ({ videoId: number }) => void
+  'ffmpeg-end': ({ videoId: number }) => void
+  'ffmpeg-error': ({ sessionId: string }) => void
+  'after-cleanup': ({ videoId: number }) => void
+}
+declare interface MuxingSession {
+  on<U extends keyof MuxingSessionEvents>(
+    event: U, listener: MuxingSessionEvents[U]
+  ): this
+  emit<U extends keyof MuxingSessionEvents>(
+    event: U, ...args: Parameters<MuxingSessionEvents[U]>
+  ): boolean
+}
+class MuxingSession extends EventEmitter {
+  private ffmpegCommand: FfmpegCommand
+  private readonly context: any
+  private readonly user: MUserId
+  private readonly sessionId: string
+  private readonly videoLive: MVideoLiveVideo
+  private readonly streamingPlaylist: MStreamingPlaylistVideo
+  private readonly rtmpUrl: string
+  private readonly fps: number
+  private readonly allResolutions: number[]
+  private readonly videoId: number
+  private readonly videoUUID: string
+  private readonly saveReplay: boolean
+  private readonly lTags: LoggerTagsFn
+  private segmentsToProcessPerPlaylist: { [playlistId: string]: string[] } = {}
+  private tsWatcher: chokidar.FSWatcher
+  private masterWatcher: chokidar.FSWatcher
+  private readonly isAbleToUploadVideoWithCache = memoizee((userId: number) => {
+    return isAbleToUploadVideo(userId, 1000)
+  }, { maxAge: MEMOIZE_TTL.LIVE_ABLE_TO_UPLOAD })
+  private readonly hasClientSocketInBadHealthWithCache = memoizee((sessionId: string) => {
+    return this.hasClientSocketInBadHealth(sessionId)
+  }, { maxAge: MEMOIZE_TTL.LIVE_CHECK_SOCKET_HEALTH })
+  constructor (options: {
+    context: any
+    user: MUserId
+    sessionId: string
+    videoLive: MVideoLiveVideo
+    streamingPlaylist: MStreamingPlaylistVideo
+    rtmpUrl: string
+    fps: number
+    allResolutions: number[]
+  }) {
+    super()
+    this.context = options.context
+    this.user = options.user
+    this.sessionId = options.sessionId
+    this.videoLive = options.videoLive
+    this.streamingPlaylist = options.streamingPlaylist
+    this.rtmpUrl = options.rtmpUrl
+    this.fps = options.fps
+    this.allResolutions = options.allResolutions
+    this.videoId = this.videoLive.Video.id
+    this.videoUUID = this.videoLive.Video.uuid
+    this.saveReplay = this.videoLive.saveReplay
+    this.lTags = loggerTagsFactory('live', this.sessionId, this.videoUUID)
+  }
+  async runMuxing () {
+    this.createFiles()
+    const outPath = await this.prepareDirectories()
+    this.ffmpegCommand = CONFIG.LIVE.TRANSCODING.ENABLED
+      ? await getLiveTranscodingCommand({
+        rtmpUrl: this.rtmpUrl,
+        outPath,
+        resolutions: this.allResolutions,
+        fps: this.fps,
+        availableEncoders: VideoTranscodingProfilesManager.Instance.getAvailableEncoders(),
+        profile: CONFIG.LIVE.TRANSCODING.PROFILE
+      })
+      : getLiveMuxingCommand(this.rtmpUrl, outPath)
+    logger.info('Running live muxing/transcoding for %s.', this.videoUUID, this.lTags)
+    this.watchTSFiles(outPath)
+    this.watchMasterFile(outPath)
+    this.ffmpegCommand.on('error', (err, stdout, stderr) => {
+      this.onFFmpegError(err, stdout, stderr, outPath)
+    })
+    this.ffmpegCommand.on('end', () => this.onFFmpegEnded(outPath))
+    this.ffmpegCommand.run()
+  }
+  abort () {
+    if (!this.ffmpegCommand) return
+    this.ffmpegCommand.kill('SIGINT')
+  }
+  destroy () {
+    this.removeAllListeners()
+    this.isAbleToUploadVideoWithCache.clear()
+    this.hasClientSocketInBadHealthWithCache.clear()
+  }
+  private onFFmpegError (err: any, stdout: string, stderr: string, outPath: string) {
+    this.onFFmpegEnded(outPath)
+    // Don't care that we killed the ffmpeg process
+    if (err?.message?.includes('Exiting normally')) return
+    logger.error('Live transcoding error.', { err, stdout, stderr, ...this.lTags })
+    this.emit('ffmpeg-error', ({ sessionId: this.sessionId }))
+  }
+  private onFFmpegEnded (outPath: string) {
+    logger.info('RTMP transmuxing for video %s ended. Scheduling cleanup', this.rtmpUrl, this.lTags)
+    setTimeout(() => {
+      // Wait latest segments generation, and close watchers
+      Promise.all([ this.tsWatcher.close(), this.masterWatcher.close() ])
+        .then(() => {
+          // Process remaining segments hash
+          for (const key of Object.keys(this.segmentsToProcessPerPlaylist)) {
+            this.processSegments(outPath, this.segmentsToProcessPerPlaylist[key])
+          }
+        })
+        .catch(err => {
+          logger.error(
+            'Cannot close watchers of %s or process remaining hash segments.', outPath,
+            { err, ...this.lTags }
+          )
+        })
+      this.emit('after-cleanup', { videoId: this.videoId })
+    }, 1000)
+  }
+  private watchMasterFile (outPath: string) {
+    this.masterWatcher = chokidar.watch(outPath + '/master.m3u8')
+    this.masterWatcher.on('add', async () => {
+      this.emit('master-playlist-created', { videoId: this.videoId })
+      this.masterWatcher.close()
+        .catch(err => logger.error('Cannot close master watcher of %s.', outPath, { err, ...this.lTags }))
+    })
+  }
+  private watchTSFiles (outPath: string) {
+    const startStreamDateTime = new Date().getTime()
+    this.tsWatcher = chokidar.watch(outPath + '/*.ts')
+    const playlistIdMatcher = /^([\d+])-/
+    const addHandler = async segmentPath => {
+      logger.debug('Live add handler of %s.', segmentPath, this.lTags)
+      const playlistId = basename(segmentPath).match(playlistIdMatcher)[0]
+      const segmentsToProcess = this.segmentsToProcessPerPlaylist[playlistId] || []
+      this.processSegments(outPath, segmentsToProcess)
+      this.segmentsToProcessPerPlaylist[playlistId] = [ segmentPath ]
+      if (this.hasClientSocketInBadHealthWithCache(this.sessionId)) {
+        this.emit('bad-socket-health', { videoId: this.videoId })
+        return
+      }
+      // Duration constraint check
+      if (this.isDurationConstraintValid(startStreamDateTime) !== true) {
+        this.emit('duration-exceeded', { videoId: this.videoId })
+        return
+      }
+      // Check user quota if the user enabled replay saving
+      if (await this.isQuotaExceeded(segmentPath) === true) {
+        this.emit('quota-exceeded', { videoId: this.videoId })
+      }
+    }
+    const deleteHandler = segmentPath => LiveSegmentShaStore.Instance.removeSegmentSha(this.videoUUID, segmentPath)
+    this.tsWatcher.on('add', p => addHandler(p))
+    this.tsWatcher.on('unlink', p => deleteHandler(p))
+  }
+  private async isQuotaExceeded (segmentPath: string) {
+    if (this.saveReplay !== true) return false
+    try {
+      const segmentStat = await stat(segmentPath)
+      LiveQuotaStore.Instance.addQuotaTo(this.user.id, this.videoLive.id, segmentStat.size)
+      const canUpload = await this.isAbleToUploadVideoWithCache(this.user.id)
+      return canUpload !== true
+    } catch (err) {
+      logger.error('Cannot stat %s or check quota of %d.', segmentPath, this.user.id, { err, ...this.lTags })
+    }
+  }
+  private createFiles () {
+    for (let i = 0; i < this.allResolutions.length; i++) {
+      const resolution = this.allResolutions[i]
+      const file = new VideoFileModel({
+        resolution,
+        size: -1,
+        extname: '.ts',
+        infoHash: null,
+        fps: this.fps,
+        videoStreamingPlaylistId: this.streamingPlaylist.id
+      })
+      VideoFileModel.customUpsert(file, 'streaming-playlist', null)
+        .catch(err => logger.error('Cannot create file for live streaming.', { err, ...this.lTags }))
+    }
+  }
+  private async prepareDirectories () {
+    const outPath = getHLSDirectory(this.videoLive.Video)
+    await ensureDir(outPath)
+    const replayDirectory = join(outPath, VIDEO_LIVE.REPLAY_DIRECTORY)
+    if (this.videoLive.saveReplay === true) {
+      await ensureDir(replayDirectory)
+    }
+    return outPath
+  }
+  private isDurationConstraintValid (streamingStartTime: number) {
+    const maxDuration = CONFIG.LIVE.MAX_DURATION
+    // No limit
+    if (maxDuration < 0) return true
+    const now = new Date().getTime()
+    const max = streamingStartTime + maxDuration
+    return now <= max
+  }
+  private processSegments (hlsVideoPath: string, segmentPaths: string[]) {
+    Bluebird.mapSeries(segmentPaths, async previousSegment => {
+      // Add sha hash of previous segments, because ffmpeg should have finished generating them
+      await LiveSegmentShaStore.Instance.addSegmentSha(this.videoUUID, previousSegment)
+      if (this.saveReplay) {
+        await this.addSegmentToReplay(hlsVideoPath, previousSegment)
+      }
+    }).catch(err => logger.error('Cannot process segments in %s', hlsVideoPath, { err, ...this.lTags }))
+  }
+  private hasClientSocketInBadHealth (sessionId: string) {
+    const rtmpSession = this.context.sessions.get(sessionId)
+    if (!rtmpSession) {
+      logger.warn('Cannot get session %s to check players socket health.', sessionId, this.lTags)
+      return
+    }
+    for (const playerSessionId of rtmpSession.players) {
+      const playerSession = this.context.sessions.get(playerSessionId)
+      if (!playerSession) {
+        logger.error('Cannot get player session %s to check socket health.', playerSession, this.lTags)
+        continue
+      }
+      if (playerSession.socket.writableLength > VIDEO_LIVE.MAX_SOCKET_WAITING_DATA) {
+        return true
+      }
+    }
+    return false
+  }
+  private async addSegmentToReplay (hlsVideoPath: string, segmentPath: string) {
+    const segmentName = basename(segmentPath)
+    const dest = join(hlsVideoPath, VIDEO_LIVE.REPLAY_DIRECTORY, buildConcatenatedName(segmentName))
+    try {
+      const data = await readFile(segmentPath)
+      await appendFile(dest, data)
+    } catch (err) {
+      logger.error('Cannot copy segment %s to replay directory.', segmentPath, { err, ...this.lTags })
+    }
+  }
+}
+// ---------------------------------------------------------------------------
+export {
+  MuxingSession
+}
diff --git a/server/lib/actor-image.ts b/server/lib/local-actor.ts
index f271f0b5b..77667f6b0 100644
--- a/server/lib/actor-image.ts
+++ b/server/lib/local-actor.ts
@@ -1,19 +1,38 @@
 import 'multer'
 import { queue } from 'async'
 import * as LRUCache from 'lru-cache'
-import { extname, join } from 'path'
+import { join } from 'path'
-import { v4 as uuidv4 } from 'uuid'
+import { getLowercaseExtension } from '@server/helpers/core-utils'
-import { ActorImageType } from '@shared/models'
+import { buildUUID } from '@server/helpers/uuid'
+import { ActorModel } from '@server/models/actor/actor'
+import { ActivityPubActorType, ActorImageType } from '@shared/models'
 import { retryTransactionWrapper } from '../helpers/database-utils'
 import { processImage } from '../helpers/image-utils'
 import { downloadImage } from '../helpers/requests'
 import { CONFIG } from '../initializers/config'
-import { ACTOR_IMAGES_SIZE, LRU_CACHE, QUEUE_CONCURRENCY } from '../initializers/constants'
+import { ACTOR_IMAGES_SIZE, LRU_CACHE, QUEUE_CONCURRENCY, WEBSERVER } from '../initializers/constants'
 import { sequelizeTypescript } from '../initializers/database'
-import { MAccountDefault, MChannelDefault } from '../types/models'
+import { MAccountDefault, MActor, MChannelDefault } from '../types/models'
-import { deleteActorImageInstance, updateActorImageInstance } from './activitypub/actor'
+import { deleteActorImageInstance, updateActorImageInstance } from './activitypub/actors'
 import { sendUpdateActor } from './activitypub/send'
+function buildActorInstance (type: ActivityPubActorType, url: string, preferredUsername: string) {
+  return new ActorModel({
+    type,
+    url,
+    preferredUsername,
+    publicKey: null,
+    privateKey: null,
+    followersCount: 0,
+    followingCount: 0,
+    inboxUrl: url + '/inbox',
+    outboxUrl: url + '/outbox',
+    sharedInboxUrl: WEBSERVER.URL + '/inbox',
+    followersUrl: url + '/followers',
+    followingUrl: url + '/following'
+  }) as MActor
+}
 async function updateLocalActorImageFile (
  accountOrChannel: MAccountDefault | MChannelDefault,
  imagePhysicalFile: Express.Multer.File,
@@ -23,9 +42,9 @@ async function updateLocalActorImageFile (
    ? ACTOR_IMAGES_SIZE.AVATARS
    : ACTOR_IMAGES_SIZE.BANNERS
-  const extension = extname(imagePhysicalFile.filename)
+  const extension = getLowercaseExtension(imagePhysicalFile.filename)
-  const imageName = uuidv4() + extension
+  const imageName = buildUUID() + extension
  const destination = join(CONFIG.STORAGE.ACTOR_IMAGES, imageName)
  await processImage(imagePhysicalFile.path, destination, imageSize)
@@ -93,5 +112,6 @@ export {
  actorImagePathUnsafeCache,
  updateLocalActorImageFile,
  deleteLocalActorImageFile,
-  pushActorImageProcessInQueue
+  pushActorImageProcessInQueue,
+  buildActorInstance
 }
diff --git a/server/lib/model-loaders/actor.ts b/server/lib/model-loaders/actor.ts
new file mode 100644
index 000000000..1355d8ee2
--- /dev/null
+++ b/server/lib/model-loaders/actor.ts
@@ -0,0 +1,17 @@
+import { ActorModel } from '../../models/actor/actor'
+import { MActorAccountChannelId, MActorFull } from '../../types/models'
+type ActorLoadByUrlType = 'all' | 'association-ids'
+function loadActorByUrl (url: string, fetchType: ActorLoadByUrlType): Promise<MActorFull | MActorAccountChannelId> {
+  if (fetchType === 'all') return ActorModel.loadByUrlAndPopulateAccountAndChannel(url)
+  if (fetchType === 'association-ids') return ActorModel.loadByUrl(url)
+}
+export {
+  ActorLoadByUrlType,
+  loadActorByUrl
+}
diff --git a/server/lib/model-loaders/index.ts b/server/lib/model-loaders/index.ts
new file mode 100644
index 000000000..9e5152cb2
--- /dev/null
+++ b/server/lib/model-loaders/index.ts
@@ -0,0 +1,2 @@
+export * from './actor'
+export * from './video'
diff --git a/server/lib/model-loaders/video.ts b/server/lib/model-loaders/video.ts
new file mode 100644
index 000000000..0a3c15ad8
--- /dev/null
+++ b/server/lib/model-loaders/video.ts
@@ -0,0 +1,73 @@
+import { VideoModel } from '@server/models/video/video'
+import {
+  MVideoAccountLightBlacklistAllFiles,
+  MVideoFormattableDetails,
+  MVideoFullLight,
+  MVideoId,
+  MVideoImmutable,
+  MVideoThumbnail
+} from '@server/types/models'
+import { Hooks } from '../plugins/hooks'
+type VideoLoadType = 'for-api' | 'all' | 'only-video' | 'id' | 'none' | 'only-immutable-attributes'
+function loadVideo (id: number | string, fetchType: 'for-api', userId?: number): Promise<MVideoFormattableDetails>
+function loadVideo (id: number | string, fetchType: 'all', userId?: number): Promise<MVideoFullLight>
+function loadVideo (id: number | string, fetchType: 'only-immutable-attributes'): Promise<MVideoImmutable>
+function loadVideo (id: number | string, fetchType: 'only-video', userId?: number): Promise<MVideoThumbnail>
+function loadVideo (id: number | string, fetchType: 'id' | 'none', userId?: number): Promise<MVideoId>
+function loadVideo (
+  id: number | string,
+  fetchType: VideoLoadType,
+  userId?: number
+): Promise<MVideoFullLight | MVideoThumbnail | MVideoId | MVideoImmutable>
+function loadVideo (
+  id: number | string,
+  fetchType: VideoLoadType,
+  userId?: number
+): Promise<MVideoFullLight | MVideoThumbnail | MVideoId | MVideoImmutable> {
+  if (fetchType === 'for-api') {
+    return Hooks.wrapPromiseFun(
+      VideoModel.loadForGetAPI,
+      { id, userId },
+      'filter:api.video.get.result'
+    )
+  }
+  if (fetchType === 'all') return VideoModel.loadAndPopulateAccountAndServerAndTags(id, undefined, userId)
+  if (fetchType === 'only-immutable-attributes') return VideoModel.loadImmutableAttributes(id)
+  if (fetchType === 'only-video') return VideoModel.load(id)
+  if (fetchType === 'id' || fetchType === 'none') return VideoModel.loadOnlyId(id)
+}
+type VideoLoadByUrlType = 'all' | 'only-video' | 'only-immutable-attributes'
+function loadVideoByUrl (url: string, fetchType: 'all'): Promise<MVideoAccountLightBlacklistAllFiles>
+function loadVideoByUrl (url: string, fetchType: 'only-immutable-attributes'): Promise<MVideoImmutable>
+function loadVideoByUrl (url: string, fetchType: 'only-video'): Promise<MVideoThumbnail>
+function loadVideoByUrl (
+  url: string,
+  fetchType: VideoLoadByUrlType
+): Promise<MVideoAccountLightBlacklistAllFiles | MVideoThumbnail | MVideoImmutable>
+function loadVideoByUrl (
+  url: string,
+  fetchType: VideoLoadByUrlType
+): Promise<MVideoAccountLightBlacklistAllFiles | MVideoThumbnail | MVideoImmutable> {
+  if (fetchType === 'all') return VideoModel.loadByUrlAndPopulateAccount(url)
+  if (fetchType === 'only-immutable-attributes') return VideoModel.loadByUrlImmutableAttributes(url)
+  if (fetchType === 'only-video') return VideoModel.loadByUrl(url)
+}
+export {
+  VideoLoadType,
+  VideoLoadByUrlType,
+  loadVideo,
+  loadVideoByUrl
+}
diff --git a/server/lib/moderation.ts b/server/lib/moderation.ts
index 925d64902..14e00518e 100644
--- a/server/lib/moderation.ts
+++ b/server/lib/moderation.ts
@@ -23,9 +23,9 @@ import { ActivityCreate } from '../../shared/models/activitypub'
 import { VideoObject } from '../../shared/models/activitypub/objects'
 import { VideoCommentObject } from '../../shared/models/activitypub/objects/video-comment-object'
 import { LiveVideoCreate, VideoCreate, VideoImportCreate } from '../../shared/models/videos'
-import { VideoCommentCreate } from '../../shared/models/videos/video-comment.model'
+import { VideoCommentCreate } from '../../shared/models/videos/comment/video-comment.model'
-import { UserModel } from '../models/account/user'
+import { ActorModel } from '../models/actor/actor'
-import { ActorModel } from '../models/activitypub/actor'
+import { UserModel } from '../models/user/user'
 import { VideoModel } from '../models/video/video'
 import { VideoCommentModel } from '../models/video/video-comment'
 import { sendAbuse } from './activitypub/send/send-flag'
@@ -221,7 +221,7 @@ async function createAbuse (options: {
  const { isOwned } = await associateFun(abuseInstance)
  if (isOwned === false) {
-    await sendAbuse(reporterAccount.Actor, abuseInstance, abuseInstance.FlaggedAccount, transaction)
+    sendAbuse(reporterAccount.Actor, abuseInstance, abuseInstance.FlaggedAccount, transaction)
  }
  const abuseJSON = abuseInstance.toFormattedAdminJSON()
diff --git a/server/lib/notifier.ts b/server/lib/notifier.ts
index da7f7cc05..1f9ff16df 100644
--- a/server/lib/notifier.ts
+++ b/server/lib/notifier.ts
@@ -17,8 +17,8 @@ import { VideoPrivacy, VideoState } from '../../shared/models/videos'
 import { logger } from '../helpers/logger'
 import { CONFIG } from '../initializers/config'
 import { AccountBlocklistModel } from '../models/account/account-blocklist'
-import { UserModel } from '../models/account/user'
+import { UserModel } from '../models/user/user'
-import { UserNotificationModel } from '../models/account/user-notification'
+import { UserNotificationModel } from '../models/user/user-notification'
 import { MAbuseFull, MAbuseMessage, MAccountServer, MActorFollowFull, MApplication, MPlugin } from '../types/models'
 import { MCommentOwnerVideo, MVideoAccountLight, MVideoFullLight } from '../types/models/video'
 import { isBlockedByServerOrAccount } from './blocklist'
diff --git a/server/lib/plugins/hooks.ts b/server/lib/plugins/hooks.ts
index aa92f03cc..5e97b52a0 100644
--- a/server/lib/plugins/hooks.ts
+++ b/server/lib/plugins/hooks.ts
@@ -1,7 +1,7 @@
-import { ServerActionHookName, ServerFilterHookName } from '../../../shared/models/plugins/server-hook.model'
-import { PluginManager } from './plugin-manager'
-import { logger } from '../../helpers/logger'
 import * as Bluebird from 'bluebird'
+import { ServerActionHookName, ServerFilterHookName } from '../../../shared/models'
+import { logger } from '../../helpers/logger'
+import { PluginManager } from './plugin-manager'
 type PromiseFunction <U, T> = (params: U) => Promise<T> | Bluebird<T>
 type RawFunction <U, T> = (params: U) => T
diff --git a/server/lib/plugins/plugin-helpers-builder.ts b/server/lib/plugins/plugin-helpers-builder.ts
index f1bc24d8b..8487672ba 100644
--- a/server/lib/plugins/plugin-helpers-builder.ts
+++ b/server/lib/plugins/plugin-helpers-builder.ts
@@ -15,9 +15,9 @@ import { MPlugin } from '@server/types/models'
 import { PeerTubeHelpers } from '@server/types/plugins'
 import { VideoBlacklistCreate } from '@shared/models'
 import { addAccountInBlocklist, addServerInBlocklist, removeAccountFromBlocklist, removeServerFromBlocklist } from '../blocklist'
-import { getServerConfig } from '../config'
+import { ServerConfigManager } from '../server-config-manager'
 import { blacklistVideo, unblacklistVideo } from '../video-blacklist'
-import { UserModel } from '@server/models/account/user'
+import { UserModel } from '@server/models/user/user'
 function buildPluginHelpers (pluginModel: MPlugin, npmName: string): PeerTubeHelpers {
  const logger = buildPluginLogger(npmName)
@@ -147,7 +147,7 @@ function buildConfigHelpers () {
    },
    getServerConfig () {
-      return getServerConfig()
+      return ServerConfigManager.Instance.getServerConfig()
    }
  }
 }
diff --git a/server/lib/plugins/plugin-index.ts b/server/lib/plugins/plugin-index.ts
index 165bc91b3..119cee8e0 100644
--- a/server/lib/plugins/plugin-index.ts
+++ b/server/lib/plugins/plugin-index.ts
@@ -1,16 +1,16 @@
 import { sanitizeUrl } from '@server/helpers/core-utils'
-import { ResultList } from '../../../shared/models'
+import { logger } from '@server/helpers/logger'
-import { PeertubePluginIndexList } from '../../../shared/models/plugins/peertube-plugin-index-list.model'
+import { doJSONRequest } from '@server/helpers/requests'
-import { PeerTubePluginIndex } from '../../../shared/models/plugins/peertube-plugin-index.model'
+import { CONFIG } from '@server/initializers/config'
+import { PEERTUBE_VERSION } from '@server/initializers/constants'
+import { PluginModel } from '@server/models/server/plugin'
 import {
+  PeerTubePluginIndex,
+  PeertubePluginIndexList,
  PeertubePluginLatestVersionRequest,
-  PeertubePluginLatestVersionResponse
+  PeertubePluginLatestVersionResponse,
-} from '../../../shared/models/plugins/peertube-plugin-latest-version.model'
+  ResultList
-import { logger } from '../../helpers/logger'
+} from '@shared/models'
-import { doJSONRequest } from '../../helpers/requests'
-import { CONFIG } from '../../initializers/config'
-import { PEERTUBE_VERSION } from '../../initializers/constants'
-import { PluginModel } from '../../models/server/plugin'
 import { PluginManager } from './plugin-manager'
 async function listAvailablePluginsFromIndex (options: PeertubePluginIndexList) {
diff --git a/server/lib/plugins/plugin-manager.ts b/server/lib/plugins/plugin-manager.ts
index ba9814383..6599bccca 100644
--- a/server/lib/plugins/plugin-manager.ts
+++ b/server/lib/plugins/plugin-manager.ts
@@ -4,16 +4,11 @@ import { createReadStream, createWriteStream } from 'fs'
 import { ensureDir, outputFile, readJSON } from 'fs-extra'
 import { basename, join } from 'path'
 import { MOAuthTokenUser, MUser } from '@server/types/models'
-import { RegisterServerHookOptions } from '@shared/models/plugins/register-server-hook.model'
+import { getCompleteLocale } from '@shared/core-utils'
+import { ClientScript, PluginPackageJson, PluginTranslation, PluginTranslationPaths, RegisterServerHookOptions } from '@shared/models'
 import { getHookType, internalRunHook } from '../../../shared/core-utils/plugins/hooks'
-import {
-  ClientScript,
-  PluginPackageJson,
-  PluginTranslationPaths as PackagePluginTranslations
-} from '../../../shared/models/plugins/plugin-package-json.model'
-import { PluginTranslation } from '../../../shared/models/plugins/plugin-translation.model'
 import { PluginType } from '../../../shared/models/plugins/plugin.type'
-import { ServerHook, ServerHookName } from '../../../shared/models/plugins/server-hook.model'
+import { ServerHook, ServerHookName } from '../../../shared/models/plugins/server/server-hook.model'
 import { isLibraryCodeValid, isPackageJSONValid } from '../../helpers/custom-validators/plugins'
 import { logger } from '../../helpers/logger'
 import { CONFIG } from '../../initializers/config'
@@ -23,7 +18,6 @@ import { PluginLibrary, RegisterServerAuthExternalOptions, RegisterServerAuthPas
 import { ClientHtml } from '../client-html'
 import { RegisterHelpers } from './register-helpers'
 import { installNpmPlugin, installNpmPluginFromDisk, removeNpmPlugin } from './yarn'
-import { getCompleteLocale } from '@shared/core-utils'
 export interface RegisteredPlugin {
  npmName: string
@@ -310,22 +304,28 @@ export class PluginManager implements ServerHook {
        uninstalled: false,
        peertubeEngine: packageJSON.engine.peertube
      }, { returning: true })
-    } catch (err) {
-      logger.error('Cannot install plugin %s, removing it...', toInstall, { err })
+      logger.info('Successful installation of plugin %s.', toInstall)
+      await this.registerPluginOrTheme(plugin)
+    } catch (rootErr) {
+      logger.error('Cannot install plugin %s, removing it...', toInstall, { err: rootErr })
      try {
-        await removeNpmPlugin(npmName)
+        await this.uninstall(npmName)
      } catch (err) {
-        logger.error('Cannot remove plugin %s after failed installation.', toInstall, { err })
+        logger.error('Cannot uninstall plugin %s after failed installation.', toInstall, { err })
+        try {
+          await removeNpmPlugin(npmName)
+        } catch (err) {
+          logger.error('Cannot remove plugin %s after failed installation.', toInstall, { err })
+        }
      }
-      throw err
+      throw rootErr
    }
-    logger.info('Successful installation of plugin %s.', toInstall)
-    await this.registerPluginOrTheme(plugin)
    return plugin
  }
@@ -431,8 +431,7 @@ export class PluginManager implements ServerHook {
    await ensureDir(registerOptions.peertubeHelpers.plugin.getDataDirectoryPath())
-    library.register(registerOptions)
+    await library.register(registerOptions)
-           .catch(err => logger.error('Cannot register plugin %s.', npmName, { err }))
    logger.info('Add plugin %s CSS to global file.', npmName)
@@ -443,7 +442,7 @@ export class PluginManager implements ServerHook {
  // ###################### Translations ######################
-  private async addTranslations (plugin: PluginModel, npmName: string, translationPaths: PackagePluginTranslations) {
+  private async addTranslations (plugin: PluginModel, npmName: string, translationPaths: PluginTranslationPaths) {
    for (const locale of Object.keys(translationPaths)) {
      const path = translationPaths[locale]
      const json = await readJSON(join(this.getPluginPath(plugin.name, plugin.type), path))
diff --git a/server/lib/plugins/register-helpers.ts b/server/lib/plugins/register-helpers.ts
index aa69ca2a2..09275f9ba 100644
--- a/server/lib/plugins/register-helpers.ts
+++ b/server/lib/plugins/register-helpers.ts
@@ -26,10 +26,10 @@ import {
  PluginVideoLicenceManager,
  PluginVideoPrivacyManager,
  RegisterServerHookOptions,
-  RegisterServerSettingOptions
+  RegisterServerSettingOptions,
+  serverHookObject
 } from '@shared/models'
-import { serverHookObject } from '@shared/models/plugins/server-hook.model'
+import { VideoTranscodingProfilesManager } from '../transcoding/video-transcoding-profiles'
-import { VideoTranscodingProfilesManager } from '../video-transcoding-profiles'
 import { buildPluginHelpers } from './plugin-helpers-builder'
 type AlterableVideoConstant = 'language' | 'licence' | 'category' | 'privacy' | 'playlistPrivacy'
@@ -37,18 +37,20 @@ type VideoConstant = { [key in number | string]: string }
 type UpdatedVideoConstant = {
  [name in AlterableVideoConstant]: {
-    added: { key: number | string, label: string }[]
+    [ npmName: string]: {
-    deleted: { key: number | string, label: string }[]
+      added: { key: number | string, label: string }[]
+      deleted: { key: number | string, label: string }[]
+    }
  }
 }
 export class RegisterHelpers {
  private readonly updatedVideoConstants: UpdatedVideoConstant = {
-    playlistPrivacy: { added: [], deleted: [] },
+    playlistPrivacy: { },
-    privacy: { added: [], deleted: [] },
+    privacy: { },
-    language: { added: [], deleted: [] },
+    language: { },
-    licence: { added: [], deleted: [] },
+    licence: { },
-    category: { added: [], deleted: [] }
+    category: { }
  }
  private readonly transcodingProfiles: {
@@ -377,7 +379,7 @@ export class RegisterHelpers {
    const { npmName, type, obj, key } = parameters
    if (!obj[key]) {
-      logger.warn('Cannot delete %s %s by plugin %s: key does not exist.', type, npmName, key)
+      logger.warn('Cannot delete %s by plugin %s: key %s does not exist.', type, npmName, key)
      return false
    }
@@ -388,7 +390,15 @@ export class RegisterHelpers {
      }
    }
-    this.updatedVideoConstants[type][npmName].deleted.push({ key, label: obj[key] })
+    const updatedConstants = this.updatedVideoConstants[type][npmName]
+    const alreadyAdded = updatedConstants.added.find(a => a.key === key)
+    if (alreadyAdded) {
+      updatedConstants.added.filter(a => a.key !== key)
+    } else if (obj[key]) {
+      updatedConstants.deleted.push({ key, label: obj[key] })
+    }
    delete obj[key]
    return true
diff --git a/server/lib/redundancy.ts b/server/lib/redundancy.ts
index da620b607..2a9241249 100644
--- a/server/lib/redundancy.ts
+++ b/server/lib/redundancy.ts
@@ -1,12 +1,12 @@
-import { VideoRedundancyModel } from '../models/redundancy/video-redundancy'
-import { sendUndoCacheFile } from './activitypub/send'
 import { Transaction } from 'sequelize'
-import { MActorSignature, MVideoRedundancyVideo } from '@server/types/models'
-import { CONFIG } from '@server/initializers/config'
 import { logger } from '@server/helpers/logger'
-import { ActorFollowModel } from '@server/models/activitypub/actor-follow'
+import { CONFIG } from '@server/initializers/config'
-import { Activity } from '@shared/models'
+import { ActorFollowModel } from '@server/models/actor/actor-follow'
 import { getServerActor } from '@server/models/application/application'
+import { MActorSignature, MVideoRedundancyVideo } from '@server/types/models'
+import { Activity } from '@shared/models'
+import { VideoRedundancyModel } from '../models/redundancy/video-redundancy'
+import { sendUndoCacheFile } from './activitypub/send'
 async function removeVideoRedundancy (videoRedundancy: MVideoRedundancyVideo, t?: Transaction) {
  const serverActor = await getServerActor()
diff --git a/server/lib/schedulers/actor-follow-scheduler.ts b/server/lib/schedulers/actor-follow-scheduler.ts
index 598c0211f..1b80316e9 100644
--- a/server/lib/schedulers/actor-follow-scheduler.ts
+++ b/server/lib/schedulers/actor-follow-scheduler.ts
@@ -1,9 +1,9 @@
 import { isTestInstance } from '../../helpers/core-utils'
 import { logger } from '../../helpers/logger'
-import { ActorFollowModel } from '../../models/activitypub/actor-follow'
-import { AbstractScheduler } from './abstract-scheduler'
 import { ACTOR_FOLLOW_SCORE, SCHEDULER_INTERVALS_MS } from '../../initializers/constants'
+import { ActorFollowModel } from '../../models/actor/actor-follow'
 import { ActorFollowScoreCache } from '../files-cache'
+import { AbstractScheduler } from './abstract-scheduler'
 export class ActorFollowScheduler extends AbstractScheduler {
diff --git a/server/lib/schedulers/auto-follow-index-instances.ts b/server/lib/schedulers/auto-follow-index-instances.ts
index 0b8cd1389..aaa5feed5 100644
--- a/server/lib/schedulers/auto-follow-index-instances.ts
+++ b/server/lib/schedulers/auto-follow-index-instances.ts
@@ -1,7 +1,7 @@
 import { chunk } from 'lodash'
 import { doJSONRequest } from '@server/helpers/requests'
 import { JobQueue } from '@server/lib/job-queue'
-import { ActorFollowModel } from '@server/models/activitypub/actor-follow'
+import { ActorFollowModel } from '@server/models/actor/actor-follow'
 import { getServerActor } from '@server/models/application/application'
 import { logger } from '../../helpers/logger'
 import { CONFIG } from '../../initializers/config'
diff --git a/server/lib/schedulers/remove-old-history-scheduler.ts b/server/lib/schedulers/remove-old-history-scheduler.ts
index 17a42b2c4..225669ea2 100644
--- a/server/lib/schedulers/remove-old-history-scheduler.ts
+++ b/server/lib/schedulers/remove-old-history-scheduler.ts
@@ -1,7 +1,7 @@
 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 { UserVideoHistoryModel } from '../../models/user/user-video-history'
 import { CONFIG } from '../../initializers/config'
 export class RemoveOldHistoryScheduler extends AbstractScheduler {
diff --git a/server/lib/schedulers/update-videos-scheduler.ts b/server/lib/schedulers/update-videos-scheduler.ts
index 3e75babcb..af69bda89 100644
--- a/server/lib/schedulers/update-videos-scheduler.ts
+++ b/server/lib/schedulers/update-videos-scheduler.ts
@@ -1,12 +1,12 @@
+import { VideoModel } from '@server/models/video/video'
+import { MVideoFullLight } from '@server/types/models'
 import { logger } from '../../helpers/logger'
-import { AbstractScheduler } from './abstract-scheduler'
+import { SCHEDULER_INTERVALS_MS } from '../../initializers/constants'
+import { sequelizeTypescript } from '../../initializers/database'
 import { ScheduleVideoUpdateModel } from '../../models/video/schedule-video-update'
-import { retryTransactionWrapper } from '../../helpers/database-utils'
 import { federateVideoIfNeeded } from '../activitypub/videos'
-import { SCHEDULER_INTERVALS_MS } from '../../initializers/constants'
 import { Notifier } from '../notifier'
-import { sequelizeTypescript } from '../../initializers/database'
+import { AbstractScheduler } from './abstract-scheduler'
-import { MVideoFullLight } from '@server/types/models'
 export class UpdateVideosScheduler extends AbstractScheduler {
@@ -19,18 +19,19 @@ export class UpdateVideosScheduler extends AbstractScheduler {
  }
  protected async internalExecute () {
-    return retryTransactionWrapper(this.updateVideos.bind(this))
+    return this.updateVideos()
  }
  private async updateVideos () {
    if (!await ScheduleVideoUpdateModel.areVideosToUpdate()) return undefined
-    const publishedVideos = await sequelizeTypescript.transaction(async t => {
+    const schedules = await ScheduleVideoUpdateModel.listVideosToUpdate()
-      const schedules = await ScheduleVideoUpdateModel.listVideosToUpdate(t)
+    const publishedVideos: MVideoFullLight[] = []
-      const publishedVideos: MVideoFullLight[] = []
+    for (const schedule of schedules) {
+      await sequelizeTypescript.transaction(async t => {
+        const video = await VideoModel.loadAndPopulateAccountAndServerAndTags(schedule.videoId, t)
-      for (const schedule of schedules) {
-        const video = schedule.Video
        logger.info('Executing scheduled video update on %s.', video.uuid)
        if (schedule.privacy) {
@@ -42,16 +43,13 @@ export class UpdateVideosScheduler extends AbstractScheduler {
          await federateVideoIfNeeded(video, isNewVideo, t)
          if (wasConfidentialVideo) {
-            const videoToPublish: MVideoFullLight = Object.assign(video, { ScheduleVideoUpdate: schedule, UserVideoHistories: [] })
+            publishedVideos.push(video)
-            publishedVideos.push(videoToPublish)
          }
        }
        await schedule.destroy({ transaction: t })
-      }
+      })
+    }
-      return publishedVideos
-    })
    for (const v of publishedVideos) {
      Notifier.Instance.notifyOnNewVideoIfNeeded(v)
diff --git a/server/lib/schedulers/videos-redundancy-scheduler.ts b/server/lib/schedulers/videos-redundancy-scheduler.ts
index 59b55cccc..b5a5eb697 100644
--- a/server/lib/schedulers/videos-redundancy-scheduler.ts
+++ b/server/lib/schedulers/videos-redundancy-scheduler.ts
@@ -23,7 +23,7 @@ import { HLS_REDUNDANCY_DIRECTORY, REDUNDANCY, VIDEO_IMPORT_TIMEOUT } from '../.
 import { VideoRedundancyModel } from '../../models/redundancy/video-redundancy'
 import { sendCreateCacheFile, sendUpdateCacheFile } from '../activitypub/send'
 import { getLocalVideoCacheFileActivityPubUrl, getLocalVideoCacheStreamingPlaylistActivityPubUrl } from '../activitypub/url'
-import { getOrCreateVideoAndAccountAndChannel } from '../activitypub/videos'
+import { getOrCreateAPVideo } from '../activitypub/videos'
 import { downloadPlaylistSegments } from '../hls'
 import { removeVideoRedundancy } from '../redundancy'
 import { generateHLSRedundancyUrl, generateWebTorrentRedundancyUrl } from '../video-paths'
@@ -351,7 +351,7 @@ export class VideosRedundancyScheduler extends AbstractScheduler {
      syncParam: { likes: false, dislikes: false, shares: false, comments: false, thumbnail: false, refreshVideo: true },
      fetchType: 'all' as 'all'
    }
-    const { video } = await getOrCreateVideoAndAccountAndChannel(getVideoOptions)
+    const { video } = await getOrCreateAPVideo(getVideoOptions)
    return video
  }
diff --git a/server/lib/schedulers/youtube-dl-update-scheduler.ts b/server/lib/schedulers/youtube-dl-update-scheduler.ts
index aefe6aba4..898691c13 100644
--- a/server/lib/schedulers/youtube-dl-update-scheduler.ts
+++ b/server/lib/schedulers/youtube-dl-update-scheduler.ts
@@ -1,6 +1,6 @@
-import { AbstractScheduler } from './abstract-scheduler'
+import { YoutubeDL } from '@server/helpers/youtube-dl'
 import { SCHEDULER_INTERVALS_MS } from '../../initializers/constants'
-import { updateYoutubeDLBinary } from '../../helpers/youtube-dl'
+import { AbstractScheduler } from './abstract-scheduler'
 export class YoutubeDlUpdateScheduler extends AbstractScheduler {
@@ -13,7 +13,7 @@ export class YoutubeDlUpdateScheduler extends AbstractScheduler {
  }
  protected internalExecute () {
-    return updateYoutubeDLBinary()
+    return YoutubeDL.updateYoutubeDLBinary()
  }
  static get Instance () {
diff --git a/server/lib/search.ts b/server/lib/search.ts
new file mode 100644
index 000000000..b643a4055
--- /dev/null
+++ b/server/lib/search.ts
@@ -0,0 +1,50 @@
+import * as express from 'express'
+import { CONFIG } from '@server/initializers/config'
+import { AccountBlocklistModel } from '@server/models/account/account-blocklist'
+import { getServerActor } from '@server/models/application/application'
+import { ServerBlocklistModel } from '@server/models/server/server-blocklist'
+import { SearchTargetQuery } from '@shared/models'
+function isSearchIndexSearch (query: SearchTargetQuery) {
+  if (query.searchTarget === 'search-index') return true
+  const searchIndexConfig = CONFIG.SEARCH.SEARCH_INDEX
+  if (searchIndexConfig.ENABLED !== true) return false
+  if (searchIndexConfig.DISABLE_LOCAL_SEARCH) return true
+  if (searchIndexConfig.IS_DEFAULT_SEARCH && !query.searchTarget) return true
+  return false
+}
+async function buildMutedForSearchIndex (res: express.Response) {
+  const serverActor = await getServerActor()
+  const accountIds = [ serverActor.Account.id ]
+  if (res.locals.oauth) {
+    accountIds.push(res.locals.oauth.token.User.Account.id)
+  }
+  const [ blockedHosts, blockedAccounts ] = await Promise.all([
+    ServerBlocklistModel.listHostsBlockedBy(accountIds),
+    AccountBlocklistModel.listHandlesBlockedBy(accountIds)
+  ])
+  return {
+    blockedHosts,
+    blockedAccounts
+  }
+}
+function isURISearch (search: string) {
+  if (!search) return false
+  return search.startsWith('http://') || search.startsWith('https://')
+}
+export {
+  isSearchIndexSearch,
+  buildMutedForSearchIndex,
+  isURISearch
+}
diff --git a/server/lib/server-config-manager.ts b/server/lib/server-config-manager.ts
new file mode 100644
index 000000000..80d87a9d3
--- /dev/null
+++ b/server/lib/server-config-manager.ts
@@ -0,0 +1,304 @@
+import { getServerCommit } from '@server/helpers/utils'
+import { CONFIG, isEmailEnabled } from '@server/initializers/config'
+import { CONSTRAINTS_FIELDS, DEFAULT_THEME_NAME, PEERTUBE_VERSION } from '@server/initializers/constants'
+import { isSignupAllowed, isSignupAllowedForCurrentIP } from '@server/lib/signup'
+import { ActorCustomPageModel } from '@server/models/account/actor-custom-page'
+import { HTMLServerConfig, RegisteredExternalAuthConfig, RegisteredIdAndPassAuthConfig, ServerConfig } from '@shared/models'
+import { Hooks } from './plugins/hooks'
+import { PluginManager } from './plugins/plugin-manager'
+import { getThemeOrDefault } from './plugins/theme-utils'
+import { VideoTranscodingProfilesManager } from './transcoding/video-transcoding-profiles'
+/**
+ *
+ * Used to send the server config to clients (using REST/API or plugins API)
+ * We need a singleton class to manage config state depending on external events (to build menu entries etc)
+ *
+ */
+class ServerConfigManager {
+  private static instance: ServerConfigManager
+  private serverCommit: string
+  private homepageEnabled = false
+  private constructor () {}
+  async init () {
+    const instanceHomepage = await ActorCustomPageModel.loadInstanceHomepage()
+    this.updateHomepageState(instanceHomepage?.content)
+  }
+  updateHomepageState (content: string) {
+    this.homepageEnabled = !!content
+  }
+  async getHTMLServerConfig (): Promise<HTMLServerConfig> {
+    if (this.serverCommit === undefined) this.serverCommit = await getServerCommit()
+    const defaultTheme = getThemeOrDefault(CONFIG.THEME.DEFAULT, DEFAULT_THEME_NAME)
+    return {
+      instance: {
+        name: CONFIG.INSTANCE.NAME,
+        shortDescription: CONFIG.INSTANCE.SHORT_DESCRIPTION,
+        isNSFW: CONFIG.INSTANCE.IS_NSFW,
+        defaultNSFWPolicy: CONFIG.INSTANCE.DEFAULT_NSFW_POLICY,
+        defaultClientRoute: CONFIG.INSTANCE.DEFAULT_CLIENT_ROUTE,
+        customizations: {
+          javascript: CONFIG.INSTANCE.CUSTOMIZATIONS.JAVASCRIPT,
+          css: CONFIG.INSTANCE.CUSTOMIZATIONS.CSS
+        }
+      },
+      search: {
+        remoteUri: {
+          users: CONFIG.SEARCH.REMOTE_URI.USERS,
+          anonymous: CONFIG.SEARCH.REMOTE_URI.ANONYMOUS
+        },
+        searchIndex: {
+          enabled: CONFIG.SEARCH.SEARCH_INDEX.ENABLED,
+          url: CONFIG.SEARCH.SEARCH_INDEX.URL,
+          disableLocalSearch: CONFIG.SEARCH.SEARCH_INDEX.DISABLE_LOCAL_SEARCH,
+          isDefaultSearch: CONFIG.SEARCH.SEARCH_INDEX.IS_DEFAULT_SEARCH
+        }
+      },
+      plugin: {
+        registered: this.getRegisteredPlugins(),
+        registeredExternalAuths: this.getExternalAuthsPlugins(),
+        registeredIdAndPassAuths: this.getIdAndPassAuthPlugins()
+      },
+      theme: {
+        registered: this.getRegisteredThemes(),
+        default: defaultTheme
+      },
+      email: {
+        enabled: isEmailEnabled()
+      },
+      contactForm: {
+        enabled: CONFIG.CONTACT_FORM.ENABLED
+      },
+      serverVersion: PEERTUBE_VERSION,
+      serverCommit: this.serverCommit,
+      transcoding: {
+        hls: {
+          enabled: CONFIG.TRANSCODING.HLS.ENABLED
+        },
+        webtorrent: {
+          enabled: CONFIG.TRANSCODING.WEBTORRENT.ENABLED
+        },
+        enabledResolutions: this.getEnabledResolutions('vod'),
+        profile: CONFIG.TRANSCODING.PROFILE,
+        availableProfiles: VideoTranscodingProfilesManager.Instance.getAvailableProfiles('vod')
+      },
+      live: {
+        enabled: CONFIG.LIVE.ENABLED,
+        allowReplay: CONFIG.LIVE.ALLOW_REPLAY,
+        maxDuration: CONFIG.LIVE.MAX_DURATION,
+        maxInstanceLives: CONFIG.LIVE.MAX_INSTANCE_LIVES,
+        maxUserLives: CONFIG.LIVE.MAX_USER_LIVES,
+        transcoding: {
+          enabled: CONFIG.LIVE.TRANSCODING.ENABLED,
+          enabledResolutions: this.getEnabledResolutions('live'),
+          profile: CONFIG.LIVE.TRANSCODING.PROFILE,
+          availableProfiles: VideoTranscodingProfilesManager.Instance.getAvailableProfiles('live')
+        },
+        rtmp: {
+          port: CONFIG.LIVE.RTMP.PORT
+        }
+      },
+      import: {
+        videos: {
+          http: {
+            enabled: CONFIG.IMPORT.VIDEOS.HTTP.ENABLED
+          },
+          torrent: {
+            enabled: CONFIG.IMPORT.VIDEOS.TORRENT.ENABLED
+          }
+        }
+      },
+      autoBlacklist: {
+        videos: {
+          ofUsers: {
+            enabled: CONFIG.AUTO_BLACKLIST.VIDEOS.OF_USERS.ENABLED
+          }
+        }
+      },
+      avatar: {
+        file: {
+          size: {
+            max: CONSTRAINTS_FIELDS.ACTORS.IMAGE.FILE_SIZE.max
+          },
+          extensions: CONSTRAINTS_FIELDS.ACTORS.IMAGE.EXTNAME
+        }
+      },
+      banner: {
+        file: {
+          size: {
+            max: CONSTRAINTS_FIELDS.ACTORS.IMAGE.FILE_SIZE.max
+          },
+          extensions: CONSTRAINTS_FIELDS.ACTORS.IMAGE.EXTNAME
+        }
+      },
+      video: {
+        image: {
+          extensions: CONSTRAINTS_FIELDS.VIDEOS.IMAGE.EXTNAME,
+          size: {
+            max: CONSTRAINTS_FIELDS.VIDEOS.IMAGE.FILE_SIZE.max
+          }
+        },
+        file: {
+          extensions: CONSTRAINTS_FIELDS.VIDEOS.EXTNAME
+        }
+      },
+      videoCaption: {
+        file: {
+          size: {
+            max: CONSTRAINTS_FIELDS.VIDEO_CAPTIONS.CAPTION_FILE.FILE_SIZE.max
+          },
+          extensions: CONSTRAINTS_FIELDS.VIDEO_CAPTIONS.CAPTION_FILE.EXTNAME
+        }
+      },
+      user: {
+        videoQuota: CONFIG.USER.VIDEO_QUOTA,
+        videoQuotaDaily: CONFIG.USER.VIDEO_QUOTA_DAILY
+      },
+      trending: {
+        videos: {
+          intervalDays: CONFIG.TRENDING.VIDEOS.INTERVAL_DAYS,
+          algorithms: {
+            enabled: CONFIG.TRENDING.VIDEOS.ALGORITHMS.ENABLED,
+            default: CONFIG.TRENDING.VIDEOS.ALGORITHMS.DEFAULT
+          }
+        }
+      },
+      tracker: {
+        enabled: CONFIG.TRACKER.ENABLED
+      },
+      followings: {
+        instance: {
+          autoFollowIndex: {
+            indexUrl: CONFIG.FOLLOWINGS.INSTANCE.AUTO_FOLLOW_INDEX.INDEX_URL
+          }
+        }
+      },
+      broadcastMessage: {
+        enabled: CONFIG.BROADCAST_MESSAGE.ENABLED,
+        message: CONFIG.BROADCAST_MESSAGE.MESSAGE,
+        level: CONFIG.BROADCAST_MESSAGE.LEVEL,
+        dismissable: CONFIG.BROADCAST_MESSAGE.DISMISSABLE
+      },
+      homepage: {
+        enabled: this.homepageEnabled
+      }
+    }
+  }
+  async getServerConfig (ip?: string): Promise<ServerConfig> {
+    const { allowed } = await Hooks.wrapPromiseFun(
+      isSignupAllowed,
+      {
+        ip
+      },
+      'filter:api.user.signup.allowed.result'
+    )
+    const allowedForCurrentIP = isSignupAllowedForCurrentIP(ip)
+    const signup = {
+      allowed,
+      allowedForCurrentIP,
+      minimumAge: CONFIG.SIGNUP.MINIMUM_AGE,
+      requiresEmailVerification: CONFIG.SIGNUP.REQUIRES_EMAIL_VERIFICATION
+    }
+    const htmlConfig = await this.getHTMLServerConfig()
+    return { ...htmlConfig, signup }
+  }
+  getRegisteredThemes () {
+    return PluginManager.Instance.getRegisteredThemes()
+                        .map(t => ({
+                          name: t.name,
+                          version: t.version,
+                          description: t.description,
+                          css: t.css,
+                          clientScripts: t.clientScripts
+                        }))
+  }
+  getRegisteredPlugins () {
+    return PluginManager.Instance.getRegisteredPlugins()
+                        .map(p => ({
+                          name: p.name,
+                          version: p.version,
+                          description: p.description,
+                          clientScripts: p.clientScripts
+                        }))
+  }
+  getEnabledResolutions (type: 'vod' | 'live') {
+    const transcoding = type === 'vod'
+      ? CONFIG.TRANSCODING
+      : CONFIG.LIVE.TRANSCODING
+    return Object.keys(transcoding.RESOLUTIONS)
+                 .filter(key => transcoding.ENABLED && transcoding.RESOLUTIONS[key] === true)
+                 .map(r => parseInt(r, 10))
+  }
+  private getIdAndPassAuthPlugins () {
+    const result: RegisteredIdAndPassAuthConfig[] = []
+    for (const p of PluginManager.Instance.getIdAndPassAuths()) {
+      for (const auth of p.idAndPassAuths) {
+        result.push({
+          npmName: p.npmName,
+          name: p.name,
+          version: p.version,
+          authName: auth.authName,
+          weight: auth.getWeight()
+        })
+      }
+    }
+    return result
+  }
+  private getExternalAuthsPlugins () {
+    const result: RegisteredExternalAuthConfig[] = []
+    for (const p of PluginManager.Instance.getExternalAuths()) {
+      for (const auth of p.externalAuths) {
+        result.push({
+          npmName: p.npmName,
+          name: p.name,
+          version: p.version,
+          authName: auth.authName,
+          authDisplayName: auth.authDisplayName()
+        })
+      }
+    }
+    return result
+  }
+  static get Instance () {
+    return this.instance || (this.instance = new this())
+  }
+}
+// ---------------------------------------------------------------------------
+export {
+  ServerConfigManager
+}
diff --git a/server/lib/signup.ts b/server/lib/signup.ts
new file mode 100644
index 000000000..8fa81e601
--- /dev/null
+++ b/server/lib/signup.ts
@@ -0,0 +1,62 @@
+import { UserModel } from '../models/user/user'
+import * as ipaddr from 'ipaddr.js'
+import { CONFIG } from '../initializers/config'
+const isCidr = require('is-cidr')
+async function isSignupAllowed (): Promise<{ allowed: boolean, errorMessage?: string }> {
+  if (CONFIG.SIGNUP.ENABLED === false) {
+    return { allowed: false }
+  }
+  // No limit and signup is enabled
+  if (CONFIG.SIGNUP.LIMIT === -1) {
+    return { allowed: true }
+  }
+  const totalUsers = await UserModel.countTotal()
+  return { allowed: totalUsers < CONFIG.SIGNUP.LIMIT }
+}
+function isSignupAllowedForCurrentIP (ip: string) {
+  if (!ip) return false
+  const addr = ipaddr.parse(ip)
+  const excludeList = [ 'blacklist' ]
+  let matched = ''
+  // if there is a valid, non-empty whitelist, we exclude all unknown adresses too
+  if (CONFIG.SIGNUP.FILTERS.CIDR.WHITELIST.filter(cidr => isCidr(cidr)).length > 0) {
+    excludeList.push('unknown')
+  }
+  if (addr.kind() === 'ipv4') {
+    const addrV4 = ipaddr.IPv4.parse(ip)
+    const rangeList = {
+      whitelist: CONFIG.SIGNUP.FILTERS.CIDR.WHITELIST.filter(cidr => isCidr.v4(cidr))
+                       .map(cidr => ipaddr.IPv4.parseCIDR(cidr)),
+      blacklist: CONFIG.SIGNUP.FILTERS.CIDR.BLACKLIST.filter(cidr => isCidr.v4(cidr))
+                       .map(cidr => ipaddr.IPv4.parseCIDR(cidr))
+    }
+    matched = ipaddr.subnetMatch(addrV4, rangeList, 'unknown')
+  } else if (addr.kind() === 'ipv6') {
+    const addrV6 = ipaddr.IPv6.parse(ip)
+    const rangeList = {
+      whitelist: CONFIG.SIGNUP.FILTERS.CIDR.WHITELIST.filter(cidr => isCidr.v6(cidr))
+                       .map(cidr => ipaddr.IPv6.parseCIDR(cidr)),
+      blacklist: CONFIG.SIGNUP.FILTERS.CIDR.BLACKLIST.filter(cidr => isCidr.v6(cidr))
+                       .map(cidr => ipaddr.IPv6.parseCIDR(cidr))
+    }
+    matched = ipaddr.subnetMatch(addrV6, rangeList, 'unknown')
+  }
+  return !excludeList.includes(matched)
+}
+// ---------------------------------------------------------------------------
+export {
+  isSignupAllowed,
+  isSignupAllowedForCurrentIP
+}
diff --git a/server/lib/stat-manager.ts b/server/lib/stat-manager.ts
index 5d703f610..3c5e0a93e 100644
--- a/server/lib/stat-manager.ts
+++ b/server/lib/stat-manager.ts
@@ -1,6 +1,6 @@
 import { CONFIG } from '@server/initializers/config'
-import { UserModel } from '@server/models/account/user'
+import { UserModel } from '@server/models/user/user'
-import { ActorFollowModel } from '@server/models/activitypub/actor-follow'
+import { ActorFollowModel } from '@server/models/actor/actor-follow'
 import { VideoRedundancyModel } from '@server/models/redundancy/video-redundancy'
 import { VideoModel } from '@server/models/video/video'
 import { VideoChannelModel } from '@server/models/video/video-channel'
diff --git a/server/lib/thumbnail.ts b/server/lib/thumbnail.ts
index cfee69cfc..c08523988 100644
--- a/server/lib/thumbnail.ts
+++ b/server/lib/thumbnail.ts
@@ -14,7 +14,7 @@ import { getVideoFilePath } from './video-paths'
 type ImageSize = { height?: number, width?: number }
-function createPlaylistMiniatureFromExisting (options: {
+function updatePlaylistMiniatureFromExisting (options: {
  inputPath: string
  playlist: MVideoPlaylistThumbnail
  automaticallyGenerated: boolean
@@ -26,7 +26,7 @@ function createPlaylistMiniatureFromExisting (options: {
  const type = ThumbnailType.MINIATURE
  const thumbnailCreator = () => processImage(inputPath, outputPath, { width, height }, keepOriginal)
-  return createThumbnailFromFunction({
+  return updateThumbnailFromFunction({
    thumbnailCreator,
    filename,
    height,
@@ -37,7 +37,7 @@ function createPlaylistMiniatureFromExisting (options: {
  })
 }
-function createPlaylistMiniatureFromUrl (options: {
+function updatePlaylistMiniatureFromUrl (options: {
  downloadUrl: string
  playlist: MVideoPlaylistThumbnail
  size?: ImageSize
@@ -52,10 +52,10 @@ function createPlaylistMiniatureFromUrl (options: {
    : downloadUrl
  const thumbnailCreator = () => downloadImage(downloadUrl, basePath, filename, { width, height })
-  return createThumbnailFromFunction({ thumbnailCreator, filename, height, width, type, existingThumbnail, fileUrl })
+  return updateThumbnailFromFunction({ thumbnailCreator, filename, height, width, type, existingThumbnail, fileUrl })
 }
-function createVideoMiniatureFromUrl (options: {
+function updateVideoMiniatureFromUrl (options: {
  downloadUrl: string
  video: MVideoThumbnail
  type: ThumbnailType
@@ -82,10 +82,10 @@ function createVideoMiniatureFromUrl (options: {
    return Promise.resolve()
  }
-  return createThumbnailFromFunction({ thumbnailCreator, filename, height, width, type, existingThumbnail, fileUrl })
+  return updateThumbnailFromFunction({ thumbnailCreator, filename, height, width, type, existingThumbnail, fileUrl })
 }
-function createVideoMiniatureFromExisting (options: {
+function updateVideoMiniatureFromExisting (options: {
  inputPath: string
  video: MVideoThumbnail
  type: ThumbnailType
@@ -98,7 +98,7 @@ function createVideoMiniatureFromExisting (options: {
  const { filename, outputPath, height, width, existingThumbnail } = buildMetadataFromVideo(video, type, size)
  const thumbnailCreator = () => processImage(inputPath, outputPath, { width, height }, keepOriginal)
-  return createThumbnailFromFunction({
+  return updateThumbnailFromFunction({
    thumbnailCreator,
    filename,
    height,
@@ -123,7 +123,7 @@ function generateVideoMiniature (options: {
    ? () => processImage(ASSETS_PATH.DEFAULT_AUDIO_BACKGROUND, outputPath, { width, height }, true)
    : () => generateImageFromVideoFile(input, basePath, filename, { height, width })
-  return createThumbnailFromFunction({
+  return updateThumbnailFromFunction({
    thumbnailCreator,
    filename,
    height,
@@ -134,7 +134,7 @@ function generateVideoMiniature (options: {
  })
 }
-function createPlaceholderThumbnail (options: {
+function updatePlaceholderThumbnail (options: {
  fileUrl: string
  video: MVideoThumbnail
  type: ThumbnailType
@@ -165,11 +165,11 @@ function createPlaceholderThumbnail (options: {
 export {
  generateVideoMiniature,
-  createVideoMiniatureFromUrl,
+  updateVideoMiniatureFromUrl,
-  createVideoMiniatureFromExisting,
+  updateVideoMiniatureFromExisting,
-  createPlaceholderThumbnail,
+  updatePlaceholderThumbnail,
-  createPlaylistMiniatureFromUrl,
+  updatePlaylistMiniatureFromUrl,
-  createPlaylistMiniatureFromExisting
+  updatePlaylistMiniatureFromExisting
 }
 function hasThumbnailUrlChanged (existingThumbnail: MThumbnail, downloadUrl: string, video: MVideoUUID) {
@@ -231,7 +231,7 @@ function buildMetadataFromVideo (video: MVideoThumbnail, type: ThumbnailType, si
  return undefined
 }
-async function createThumbnailFromFunction (parameters: {
+async function updateThumbnailFromFunction (parameters: {
  thumbnailCreator: () => Promise<any>
  filename: string
  height: number
diff --git a/server/lib/video-transcoding-profiles.ts b/server/lib/transcoding/video-transcoding-profiles.ts
index 81f5e1962..c5ea72a5f 100644
--- a/server/lib/video-transcoding-profiles.ts
+++ b/server/lib/transcoding/video-transcoding-profiles.ts
@@ -1,6 +1,6 @@
 import { logger } from '@server/helpers/logger'
-import { AvailableEncoders, EncoderOptionsBuilder, getTargetBitrate, VideoResolution } from '../../shared/models/videos'
+import { AvailableEncoders, EncoderOptionsBuilder, getTargetBitrate, VideoResolution } from '../../../shared/models/videos'
-import { buildStreamSuffix, resetSupportedEncoders } from '../helpers/ffmpeg-utils'
+import { buildStreamSuffix, resetSupportedEncoders } from '../../helpers/ffmpeg-utils'
 import {
  canDoQuickAudioTranscode,
  ffprobePromise,
@@ -8,8 +8,8 @@ import {
  getMaxAudioBitrate,
  getVideoFileBitrate,
  getVideoStreamFromFile
-} from '../helpers/ffprobe-utils'
+} from '../../helpers/ffprobe-utils'
-import { VIDEO_TRANSCODING_FPS } from '../initializers/constants'
+import { VIDEO_TRANSCODING_FPS } from '../../initializers/constants'
 /**
 *
diff --git a/server/lib/video-transcoding.ts b/server/lib/transcoding/video-transcoding.ts
index c949dca2e..1ad63baf3 100644
--- a/server/lib/video-transcoding.ts
+++ b/server/lib/transcoding/video-transcoding.ts
@@ -1,19 +1,20 @@
 import { Job } from 'bull'
 import { copyFile, ensureDir, move, remove, stat } from 'fs-extra'
 import { basename, extname as extnameUtil, join } from 'path'
+import { toEven } from '@server/helpers/core-utils'
 import { createTorrentAndSetInfoHash } from '@server/helpers/webtorrent'
 import { MStreamingPlaylistFilesVideo, MVideoFile, MVideoFullLight } from '@server/types/models'
-import { VideoResolution } from '../../shared/models/videos'
+import { VideoResolution } from '../../../shared/models/videos'
-import { VideoStreamingPlaylistType } from '../../shared/models/videos/video-streaming-playlist.type'
+import { VideoStreamingPlaylistType } from '../../../shared/models/videos/video-streaming-playlist.type'
-import { transcode, TranscodeOptions, TranscodeOptionsType } from '../helpers/ffmpeg-utils'
+import { transcode, TranscodeOptions, TranscodeOptionsType } from '../../helpers/ffmpeg-utils'
-import { canDoQuickTranscode, getDurationFromVideoFile, getMetadataFromFile, getVideoFileFPS } from '../helpers/ffprobe-utils'
+import { canDoQuickTranscode, getDurationFromVideoFile, getMetadataFromFile, getVideoFileFPS } from '../../helpers/ffprobe-utils'
-import { logger } from '../helpers/logger'
+import { logger } from '../../helpers/logger'
-import { CONFIG } from '../initializers/config'
+import { CONFIG } from '../../initializers/config'
-import { HLS_STREAMING_PLAYLIST_DIRECTORY, P2P_MEDIA_LOADER_PEER_VERSION, WEBSERVER } from '../initializers/constants'
+import { HLS_STREAMING_PLAYLIST_DIRECTORY, P2P_MEDIA_LOADER_PEER_VERSION, WEBSERVER } from '../../initializers/constants'
-import { VideoFileModel } from '../models/video/video-file'
+import { VideoFileModel } from '../../models/video/video-file'
-import { VideoStreamingPlaylistModel } from '../models/video/video-streaming-playlist'
+import { VideoStreamingPlaylistModel } from '../../models/video/video-streaming-playlist'
-import { updateMasterHLSPlaylist, updateSha256VODSegments } from './hls'
+import { updateMasterHLSPlaylist, updateSha256VODSegments } from '../hls'
-import { generateVideoFilename, generateVideoStreamingPlaylistName, getVideoFilePath } from './video-paths'
+import { generateVideoFilename, generateVideoStreamingPlaylistName, getVideoFilePath } from '../video-paths'
 import { VideoTranscodingProfilesManager } from './video-transcoding-profiles'
 /**
@@ -35,6 +36,8 @@ async function optimizeOriginalVideofile (video: MVideoFullLight, inputVideoFile
    ? 'quick-transcode'
    : 'video'
+  const resolution = toEven(inputVideoFile.resolution)
  const transcodeOptions: TranscodeOptions = {
    type: transcodeType,
@@ -44,7 +47,7 @@ async function optimizeOriginalVideofile (video: MVideoFullLight, inputVideoFile
    availableEncoders: VideoTranscodingProfilesManager.Instance.getAvailableEncoders(),
    profile: CONFIG.TRANSCODING.PROFILE,
-    resolution: inputVideoFile.resolution,
+    resolution,
    job
  }
@@ -57,7 +60,7 @@ async function optimizeOriginalVideofile (video: MVideoFullLight, inputVideoFile
    // Important to do this before getVideoFilename() to take in account the new filename
    inputVideoFile.extname = newExtname
-    inputVideoFile.filename = generateVideoFilename(video, false, inputVideoFile.resolution, newExtname)
+    inputVideoFile.filename = generateVideoFilename(video, false, resolution, newExtname)
    const videoOutputPath = getVideoFilePath(video, inputVideoFile)
@@ -215,16 +218,6 @@ function generateHlsPlaylistResolution (options: {
  })
 }
-function getEnabledResolutions (type: 'vod' | 'live') {
-  const transcoding = type === 'vod'
-    ? CONFIG.TRANSCODING
-    : CONFIG.LIVE.TRANSCODING
-  return Object.keys(transcoding.RESOLUTIONS)
-               .filter(key => transcoding.ENABLED && transcoding.RESOLUTIONS[key] === true)
-               .map(r => parseInt(r, 10))
-}
 // ---------------------------------------------------------------------------
 export {
@@ -232,8 +225,7 @@ export {
  generateHlsPlaylistResolutionFromTS,
  optimizeOriginalVideofile,
  transcodeNewWebTorrentResolution,
-  mergeAudioVideofile,
+  mergeAudioVideofile
-  getEnabledResolutions
 }
 // ---------------------------------------------------------------------------
diff --git a/server/lib/user.ts b/server/lib/user.ts
index 9b0a0a2f1..936403692 100644
--- a/server/lib/user.ts
+++ b/server/lib/user.ts
@@ -1,19 +1,21 @@
 import { Transaction } from 'sequelize/types'
-import { v4 as uuidv4 } from 'uuid'
+import { buildUUID } from '@server/helpers/uuid'
-import { UserModel } from '@server/models/account/user'
+import { UserModel } from '@server/models/user/user'
+import { MActorDefault } from '@server/types/models/actor'
 import { ActivityPubActorType } from '../../shared/models/activitypub'
 import { UserNotificationSetting, UserNotificationSettingValue } from '../../shared/models/users'
 import { SERVER_ACTOR_NAME, WEBSERVER } from '../initializers/constants'
 import { sequelizeTypescript } from '../initializers/database'
 import { AccountModel } from '../models/account/account'
-import { UserNotificationSettingModel } from '../models/account/user-notification-setting'
+import { ActorModel } from '../models/actor/actor'
-import { ActorModel } from '../models/activitypub/actor'
+import { UserNotificationSettingModel } from '../models/user/user-notification-setting'
-import { MAccountDefault, MActorDefault, MChannelActor } from '../types/models'
+import { MAccountDefault, MChannelActor } from '../types/models'
 import { MUser, MUserDefault, MUserId } from '../types/models/user'
-import { buildActorInstance, generateAndSaveActorKeys } from './activitypub/actor'
+import { generateAndSaveActorKeys } from './activitypub/actors'
 import { getLocalAccountActivityPubUrl } from './activitypub/url'
 import { Emailer } from './emailer'
-import { LiveManager } from './live-manager'
+import { LiveQuotaStore } from './live/live-quota-store'
+import { buildActorInstance } from './local-actor'
 import { Redis } from './redis'
 import { createLocalVideoChannel } from './video-channel'
 import { createWatchLaterPlaylist } from './video-playlist'
@@ -42,11 +44,11 @@ async function createUserAccountAndChannelAndPlaylist (parameters: {
      displayName: userDisplayName,
      userId: userCreated.id,
      applicationId: null,
-      t: t
+      t
    })
    userCreated.Account = accountCreated
-    const channelAttributes = await buildChannelAttributes(userCreated, channelNames)
+    const channelAttributes = await buildChannelAttributes(userCreated, t, channelNames)
    const videoChannel = await createLocalVideoChannel(channelAttributes, accountCreated, t)
    const videoPlaylist = await createWatchLaterPlaylist(accountCreated, t)
@@ -127,7 +129,7 @@ async function getOriginalVideoFileTotalFromUser (user: MUserId) {
  const base = await UserModel.getTotalRawQuery(query, user.id)
-  return base + LiveManager.Instance.getLiveQuotaUsedByUser(user.id)
+  return base + LiveQuotaStore.Instance.getLiveQuotaOf(user.id)
 }
 // Returns cumulative size of all video files uploaded in the last 24 hours.
@@ -141,10 +143,10 @@ async function getOriginalVideoFileTotalDailyFromUser (user: MUserId) {
  const base = await UserModel.getTotalRawQuery(query, user.id)
-  return base + LiveManager.Instance.getLiveQuotaUsedByUser(user.id)
+  return base + LiveQuotaStore.Instance.getLiveQuotaOf(user.id)
 }
-async function isAbleToUploadVideo (userId: number, size: number) {
+async function isAbleToUploadVideo (userId: number, newVideoSize: number) {
  const user = await UserModel.loadById(userId)
  if (user.videoQuota === -1 && user.videoQuotaDaily === -1) return Promise.resolve(true)
@@ -154,8 +156,8 @@ async function isAbleToUploadVideo (userId: number, size: number) {
    getOriginalVideoFileTotalDailyFromUser(user)
  ])
-  const uploadedTotal = size + totalBytes
+  const uploadedTotal = newVideoSize + totalBytes
-  const uploadedDaily = size + totalBytesDaily
+  const uploadedDaily = newVideoSize + totalBytesDaily
  if (user.videoQuotaDaily === -1) return uploadedTotal < user.videoQuota
  if (user.videoQuota === -1) return uploadedDaily < user.videoQuotaDaily
@@ -201,14 +203,14 @@ function createDefaultUserNotificationSettings (user: MUserId, t: Transaction |
  return UserNotificationSettingModel.create(values, { transaction: t })
 }
-async function buildChannelAttributes (user: MUser, channelNames?: ChannelNames) {
+async function buildChannelAttributes (user: MUser, transaction?: Transaction, channelNames?: ChannelNames) {
  if (channelNames) return channelNames
  let channelName = user.username + '_channel'
  // Conflict, generate uuid instead
-  const actor = await ActorModel.loadLocalByName(channelName)
+  const actor = await ActorModel.loadLocalByName(channelName, transaction)
-  if (actor) channelName = uuidv4()
+  if (actor) channelName = buildUUID()
  const videoChannelDisplayName = `Main ${user.username} channel`
diff --git a/server/lib/video-blacklist.ts b/server/lib/video-blacklist.ts
index 37c43c3b0..0984c0d7a 100644
--- a/server/lib/video-blacklist.ts
+++ b/server/lib/video-blacklist.ts
@@ -16,7 +16,7 @@ import { CONFIG } from '../initializers/config'
 import { VideoBlacklistModel } from '../models/video/video-blacklist'
 import { sendDeleteVideo } from './activitypub/send'
 import { federateVideoIfNeeded } from './activitypub/videos'
-import { LiveManager } from './live-manager'
+import { LiveManager } from './live/live-manager'
 import { Notifier } from './notifier'
 import { Hooks } from './plugins/hooks'
diff --git a/server/lib/video-channel.ts b/server/lib/video-channel.ts
index 0476cb2d5..2fd63a8c4 100644
--- a/server/lib/video-channel.ts
+++ b/server/lib/video-channel.ts
@@ -1,17 +1,15 @@
 import * as Sequelize from 'sequelize'
-import { v4 as uuidv4 } from 'uuid'
 import { VideoChannelCreate } from '../../shared/models'
 import { VideoModel } from '../models/video/video'
 import { VideoChannelModel } from '../models/video/video-channel'
 import { MAccountId, MChannelId } from '../types/models'
-import { buildActorInstance } from './activitypub/actor'
 import { getLocalVideoChannelActivityPubUrl } from './activitypub/url'
 import { federateVideoIfNeeded } from './activitypub/videos'
+import { buildActorInstance } from './local-actor'
 async function createLocalVideoChannel (videoChannelInfo: VideoChannelCreate, account: MAccountId, t: Sequelize.Transaction) {
-  const uuid = uuidv4()
  const url = getLocalVideoChannelActivityPubUrl(videoChannelInfo.name)
-  const actorInstance = buildActorInstance('Group', url, videoChannelInfo.name, uuid)
+  const actorInstance = buildActorInstance('Group', url, videoChannelInfo.name)
  const actorInstanceCreated = await actorInstance.save({ transaction: t })
diff --git a/server/lib/video-comment.ts b/server/lib/video-comment.ts
index 736ebb2f8..c76570a5d 100644
--- a/server/lib/video-comment.ts
+++ b/server/lib/video-comment.ts
@@ -3,7 +3,7 @@ import * as Sequelize from 'sequelize'
 import { logger } from '@server/helpers/logger'
 import { sequelizeTypescript } from '@server/initializers/database'
 import { ResultList } from '../../shared/models'
-import { VideoCommentThreadTree } from '../../shared/models/videos/video-comment.model'
+import { VideoCommentThreadTree } from '../../shared/models/videos/comment/video-comment.model'
 import { VideoCommentModel } from '../models/video/video-comment'
 import { MAccountDefault, MComment, MCommentOwnerVideo, MCommentOwnerVideoReply, MVideoFullLight } from '../types/models'
 import { sendCreateVideoComment, sendDeleteVideoComment } from './activitypub/send'
@@ -18,9 +18,9 @@ async function removeComment (videoCommentInstance: MCommentOwnerVideo) {
      await sendDeleteVideoComment(videoCommentInstance, t)
    }
-    markCommentAsDeleted(videoCommentInstance)
+    videoCommentInstance.markAsDeleted()
-    await videoCommentInstance.save()
+    await videoCommentInstance.save({ transaction: t })
  })
  logger.info('Video comment %d deleted.', videoCommentInstance.id)
@@ -95,17 +95,10 @@ function buildFormattedCommentTree (resultList: ResultList<VideoCommentModel>):
  return thread
 }
-function markCommentAsDeleted (comment: MComment): void {
-  comment.text = ''
-  comment.deletedAt = new Date()
-  comment.accountId = null
-}
 // ---------------------------------------------------------------------------
 export {
  removeComment,
  createVideoComment,
-  buildFormattedCommentTree,
+  buildFormattedCommentTree
-  markCommentAsDeleted
 }
diff --git a/server/lib/video.ts b/server/lib/video.ts
index 21e4b7ff2..daf998704 100644
--- a/server/lib/video.ts
+++ b/server/lib/video.ts
@@ -10,7 +10,7 @@ import { ThumbnailType, VideoCreate, VideoPrivacy, VideoTranscodingPayload } fro
 import { federateVideoIfNeeded } from './activitypub/videos'
 import { JobQueue } from './job-queue/job-queue'
 import { Notifier } from './notifier'
-import { createVideoMiniatureFromExisting } from './thumbnail'
+import { updateVideoMiniatureFromExisting } from './thumbnail'
 function buildLocalVideoFromReq (videoInfo: VideoCreate, channelId: number): FilteredModelAttributes<VideoModel> {
  return {
@@ -28,6 +28,8 @@ function buildLocalVideoFromReq (videoInfo: VideoCreate, channelId: number): Fil
    privacy: videoInfo.privacy || VideoPrivacy.PRIVATE,
    channelId: channelId,
    originallyPublishedAt: videoInfo.originallyPublishedAt
+      ? new Date(videoInfo.originallyPublishedAt)
+      : null
  }
 }
@@ -52,7 +54,7 @@ async function buildVideoThumbnailsFromReq (options: {
    const fields = files?.[p.fieldName]
    if (fields) {
-      return createVideoMiniatureFromExisting({
+      return updateVideoMiniatureFromExisting({
        inputPath: fields[0].path,
        video,
        type: p.type,