59 files changed, 1490 insertions, 680 deletions
diff --git a/server/middlewares/activitypub.ts b/server/middlewares/activitypub.ts
index ce94a2129..6b43b7764 100644
--- a/server/middlewares/activitypub.ts
+++ b/server/middlewares/activitypub.ts
@@ -1,13 +1,12 @@
 import { NextFunction, Request, Response } from 'express'
+import { getAPId } from '@server/helpers/activitypub'
+import { isActorDeleteActivityValid } from '@server/helpers/custom-validators/activitypub/actor'
 import { ActivityDelete, ActivityPubSignature } from '../../shared'
+import { HttpStatusCode } from '../../shared/core-utils/miscs/http-error-codes'
 import { logger } from '../helpers/logger'
 import { isHTTPSignatureVerified, isJsonLDSignatureVerified, parseHTTPSignature } from '../helpers/peertube-crypto'
 import { ACCEPT_HEADERS, ACTIVITY_PUB, HTTP_SIGNATURE } from '../initializers/constants'
-import { getOrCreateActorAndServerAndModel } from '../lib/activitypub/actor'
+import { getOrCreateAPActor, loadActorUrlOrGetFromWebfinger } from '../lib/activitypub/actors'
-import { loadActorUrlOrGetFromWebfinger } from '../helpers/webfinger'
-import { isActorDeleteActivityValid } from '@server/helpers/custom-validators/activitypub/actor'
-import { getAPId } from '@server/helpers/activitypub'
-import { HttpStatusCode } from '../../shared/core-utils/miscs/http-error-codes'
 async function checkSignature (req: Request, res: Response, next: NextFunction) {
  try {
@@ -29,11 +28,14 @@ async function checkSignature (req: Request, res: Response, next: NextFunction)
    const activity: ActivityDelete = req.body
    if (isActorDeleteActivityValid(activity) && activity.object === activity.actor) {
      logger.debug('Handling signature error on actor delete activity', { err })
-      return res.sendStatus(HttpStatusCode.NO_CONTENT_204)
+      return res.status(HttpStatusCode.NO_CONTENT_204).end()
    }
    logger.warn('Error in ActivityPub signature checker.', { err })
-    return res.sendStatus(HttpStatusCode.FORBIDDEN_403)
+    return res.fail({
+      status: HttpStatusCode.FORBIDDEN_403,
+      message: 'ActivityPub signature could not be checked'
+    })
  }
 }
@@ -71,13 +73,22 @@ async function checkHttpSignature (req: Request, res: Response) {
  } catch (err) {
    logger.warn('Invalid signature because of exception in signature parser', { reqBody: req.body, err })
-    res.status(HttpStatusCode.FORBIDDEN_403).json({ error: err.message })
+    res.fail({
+      status: HttpStatusCode.FORBIDDEN_403,
+      message: err.message
+    })
    return false
  }
  const keyId = parsed.keyId
  if (!keyId) {
-    res.sendStatus(HttpStatusCode.FORBIDDEN_403)
+    res.fail({
+      status: HttpStatusCode.FORBIDDEN_403,
+      message: 'Invalid key ID',
+      data: {
+        keyId
+      }
+    })
    return false
  }
@@ -88,18 +99,23 @@ async function checkHttpSignature (req: Request, res: Response) {
    actorUrl = await loadActorUrlOrGetFromWebfinger(actorUrl.replace(/^acct:/, ''))
  }
-  const actor = await getOrCreateActorAndServerAndModel(actorUrl)
+  const actor = await getOrCreateAPActor(actorUrl)
  const verified = isHTTPSignatureVerified(parsed, actor)
  if (verified !== true) {
    logger.warn('Signature from %s is invalid', actorUrl, { parsed })
-    res.sendStatus(HttpStatusCode.FORBIDDEN_403)
+    res.fail({
+      status: HttpStatusCode.FORBIDDEN_403,
+      message: 'Invalid signature',
+      data: {
+        actorUrl
+      }
+    })
    return false
  }
  res.locals.signature = { actor }
  return true
 }
@@ -107,7 +123,10 @@ async function checkJsonLDSignature (req: Request, res: Response) {
  const signatureObject: ActivityPubSignature = req.body.signature
  if (!signatureObject || !signatureObject.creator) {
-    res.sendStatus(HttpStatusCode.FORBIDDEN_403)
+    res.fail({
+      status: HttpStatusCode.FORBIDDEN_403,
+      message: 'Object and creator signature do not match'
+    })
    return false
  }
@@ -115,17 +134,19 @@ async function checkJsonLDSignature (req: Request, res: Response) {
  logger.debug('Checking JsonLD signature of actor %s...', creator)
-  const actor = await getOrCreateActorAndServerAndModel(creator)
+  const actor = await getOrCreateAPActor(creator)
  const verified = await isJsonLDSignatureVerified(actor, req.body)
  if (verified !== true) {
    logger.warn('Signature not verified.', req.body)
-    res.sendStatus(HttpStatusCode.FORBIDDEN_403)
+    res.fail({
+      status: HttpStatusCode.FORBIDDEN_403,
+      message: 'Signature could not be verified'
+    })
    return false
  }
  res.locals.signature = { actor }
  return true
 }
diff --git a/server/middlewares/auth.ts b/server/middlewares/auth.ts
index f38373624..176461cc2 100644
--- a/server/middlewares/auth.ts
+++ b/server/middlewares/auth.ts
@@ -16,11 +16,11 @@ function authenticate (req: express.Request, res: express.Response, next: expres
    .catch(err => {
      logger.warn('Cannot authenticate.', { err })
-      return res.status(err.status)
+      return res.fail({
-        .json({
+        status: err.status,
-          error: 'Token is invalid.',
+        message: 'Token is invalid',
-          code: err.name
+        type: err.name
-        })
+      })
    })
 }
@@ -52,7 +52,12 @@ function authenticatePromiseIfNeeded (req: express.Request, res: express.Respons
    // Already authenticated? (or tried to)
    if (res.locals.oauth?.token.User) return resolve()
-    if (res.locals.authenticated === false) return res.sendStatus(HttpStatusCode.UNAUTHORIZED_401)
+    if (res.locals.authenticated === false) {
+      return res.fail({
+        status: HttpStatusCode.UNAUTHORIZED_401,
+        message: 'Not authenticated'
+      })
+    }
    authenticate(req, res, () => resolve(), authenticateInQuery)
  })
diff --git a/server/middlewares/doc.ts b/server/middlewares/doc.ts
new file mode 100644
index 000000000..3db85c68d
--- /dev/null
+++ b/server/middlewares/doc.ts
@@ -0,0 +1,16 @@
+import * as express from 'express'
+function openapiOperationDoc (options: {
+  url?: string
+  operationId?: string
+}) {
+  return (req: express.Request, res: express.Response, next: express.NextFunction) => {
+    res.locals.docUrl = options.url || 'https://docs.joinpeertube.org/api-rest-reference.html#operation/' + options.operationId
+    if (next) return next()
+  }
+}
+export {
+  openapiOperationDoc
+}
diff --git a/server/middlewares/error.ts b/server/middlewares/error.ts
new file mode 100644
index 000000000..e3eb1c8f5
--- /dev/null
+++ b/server/middlewares/error.ts
@@ -0,0 +1,39 @@
+import * as express from 'express'
+import { ProblemDocument, ProblemDocumentExtension } from 'http-problem-details'
+import { HttpStatusCode } from '@shared/core-utils'
+function apiFailMiddleware (req: express.Request, res: express.Response, next: express.NextFunction) {
+  res.fail = options => {
+    const { status = HttpStatusCode.BAD_REQUEST_400, message, title, type, data, instance } = options
+    const extension = new ProblemDocumentExtension({
+      ...data,
+      docs: res.locals.docUrl,
+      code: type,
+      // For <= 3.2 compatibility
+      error: message
+    })
+    res.status(status)
+    res.setHeader('Content-Type', 'application/problem+json')
+    res.json(new ProblemDocument({
+      status,
+      title,
+      instance,
+      detail: message,
+      type: type
+        ? `https://docs.joinpeertube.org/api-rest-reference.html#section/Errors/${type}`
+        : undefined
+    }, extension))
+  }
+  if (next) next()
+}
+export {
+  apiFailMiddleware
+}
diff --git a/server/middlewares/index.ts b/server/middlewares/index.ts
index 3e280e16f..413653dac 100644
--- a/server/middlewares/index.ts
+++ b/server/middlewares/index.ts
@@ -7,4 +7,6 @@ export * from './servers'
 export * from './sort'
 export * from './user-right'
 export * from './dnt'
+export * from './error'
+export * from './doc'
 export * from './csp'
diff --git a/server/middlewares/servers.ts b/server/middlewares/servers.ts
index 5e1c165f0..9aa56bc93 100644
--- a/server/middlewares/servers.ts
+++ b/server/middlewares/servers.ts
@@ -10,7 +10,10 @@ function setBodyHostsPort (req: express.Request, res: express.Response, next: ex
    // Problem with the url parsing?
    if (hostWithPort === null) {
-      return res.sendStatus(HttpStatusCode.INTERNAL_SERVER_ERROR_500)
+      return res.fail({
+        status: HttpStatusCode.INTERNAL_SERVER_ERROR_500,
+        message: 'Could not parse hosts'
+      })
    }
    req.body.hosts[i] = hostWithPort
diff --git a/server/middlewares/user-right.ts b/server/middlewares/user-right.ts
index 45dda4781..d1888c2d3 100644
--- a/server/middlewares/user-right.ts
+++ b/server/middlewares/user-right.ts
@@ -10,8 +10,10 @@ function ensureUserHasRight (userRight: UserRight) {
      const message = `User ${user.username} does not have right ${userRight} to access to ${req.path}.`
      logger.info(message)
-      return res.status(HttpStatusCode.FORBIDDEN_403)
+      return res.fail({
-                .json({ error: message })
+        status: HttpStatusCode.FORBIDDEN_403,
+        message
+      })
    }
    return next()
diff --git a/server/middlewares/validators/abuse.ts b/server/middlewares/validators/abuse.ts
index 3b897fdef..c048bc6af 100644
--- a/server/middlewares/validators/abuse.ts
+++ b/server/middlewares/validators/abuse.ts
@@ -12,14 +12,12 @@ import {
  isAbuseTimestampValid,
  isAbuseVideoIsValid
 } from '@server/helpers/custom-validators/abuses'
-import { exists, isIdOrUUIDValid, isIdValid, toIntOrNull } from '@server/helpers/custom-validators/misc'
+import { exists, isIdOrUUIDValid, isIdValid, toCompleteUUID, toIntOrNull } from '@server/helpers/custom-validators/misc'
-import { doesCommentIdExist } from '@server/helpers/custom-validators/video-comments'
 import { logger } from '@server/helpers/logger'
-import { doesAbuseExist, doesAccountIdExist, doesVideoExist } from '@server/helpers/middlewares'
 import { AbuseMessageModel } from '@server/models/abuse/abuse-message'
 import { AbuseCreate, UserRight } from '@shared/models'
-import { areValidationErrors } from './utils'
 import { HttpStatusCode } from '../../../shared/core-utils/miscs/http-error-codes'
+import { areValidationErrors, doesAbuseExist, doesAccountIdExist, doesCommentIdExist, doesVideoExist } from './shared'
 const abuseReportValidator = [
  body('account.id')
@@ -29,6 +27,7 @@ const abuseReportValidator = [
  body('video.id')
    .optional()
+    .customSanitizer(toCompleteUUID)
    .custom(isIdOrUUIDValid)
    .withMessage('Should have a valid videoId'),
  body('video.startAt')
@@ -71,9 +70,7 @@ const abuseReportValidator = [
    if (body.comment?.id && !await doesCommentIdExist(body.comment.id, res)) return
    if (!body.video?.id && !body.account?.id && !body.comment?.id) {
-      res.status(HttpStatusCode.BAD_REQUEST_400)
+      res.fail({ message: 'video id or account id or comment id is required.' })
-         .json({ error: 'video id or account id or comment id is required.' })
      return
    }
@@ -195,8 +192,10 @@ const getAbuseValidator = [
      const message = `User ${user.username} does not have right to get abuse ${abuse.id}`
      logger.warn(message)
-      return res.status(HttpStatusCode.FORBIDDEN_403)
+      return res.fail({
-                .json({ error: message })
+        status: HttpStatusCode.FORBIDDEN_403,
+        message
+      })
    }
    return next()
@@ -209,10 +208,7 @@ const checkAbuseValidForMessagesValidator = [
    const abuse = res.locals.abuse
    if (abuse.ReporterAccount.isOwned() === false) {
-      return res.status(HttpStatusCode.BAD_REQUEST_400)
+      return res.fail({ message: 'This abuse was created by a user of your instance.' })
-                .json({
-                  error: 'This abuse was created by a user of your instance.'
-                })
    }
    return next()
@@ -246,13 +242,17 @@ const deleteAbuseMessageValidator = [
    const abuseMessage = await AbuseMessageModel.loadByIdAndAbuseId(messageId, abuse.id)
    if (!abuseMessage) {
-      return res.status(HttpStatusCode.NOT_FOUND_404)
+      return res.fail({
-                .json({ error: 'Abuse message not found' })
+        status: HttpStatusCode.NOT_FOUND_404,
+        message: 'Abuse message not found'
+      })
    }
    if (user.hasRight(UserRight.MANAGE_ABUSES) !== true && abuseMessage.accountId !== user.Account.id) {
-      return res.status(HttpStatusCode.FORBIDDEN_403)
+      return res.fail({
-                .json({ error: 'Cannot delete this abuse message' })
+        status: HttpStatusCode.FORBIDDEN_403,
+        message: 'Cannot delete this abuse message'
+      })
    }
    res.locals.abuseMessage = abuseMessage
diff --git a/server/middlewares/validators/account.ts b/server/middlewares/validators/account.ts
index cbdcef2fd..599eb10bb 100644
--- a/server/middlewares/validators/account.ts
+++ b/server/middlewares/validators/account.ts
@@ -2,8 +2,7 @@ import * as express from 'express'
 import { param } from 'express-validator'
 import { isAccountNameValid } from '../../helpers/custom-validators/accounts'
 import { logger } from '../../helpers/logger'
-import { areValidationErrors } from './utils'
+import { areValidationErrors, doesAccountNameWithHostExist, doesLocalAccountNameExist } from './shared'
-import { doesAccountNameWithHostExist, doesLocalAccountNameExist } from '../../helpers/middlewares'
 const localAccountValidator = [
  param('name').custom(isAccountNameValid).withMessage('Should have a valid account name'),
diff --git a/server/middlewares/validators/activitypub/activity.ts b/server/middlewares/validators/activitypub/activity.ts
index e78ef07ef..cc6acd4b1 100644
--- a/server/middlewares/validators/activitypub/activity.ts
+++ b/server/middlewares/validators/activitypub/activity.ts
@@ -9,16 +9,14 @@ async function activityPubValidator (req: express.Request, res: express.Response
  if (!isRootActivityValid(req.body)) {
    logger.warn('Incorrect activity parameters.', { activity: req.body })
-    return res.status(HttpStatusCode.BAD_REQUEST_400)
+    return res.fail({ message: 'Incorrect activity' })
-              .json({ error: 'Incorrect activity.' })
  }
  const serverActor = await getServerActor()
  const remoteActor = res.locals.signature.actor
  if (serverActor.id === remoteActor.id || remoteActor.serverId === null) {
    logger.error('Receiving request in INBOX by ourselves!', req.body)
-    return res.status(HttpStatusCode.CONFLICT_409)
+    return res.status(HttpStatusCode.CONFLICT_409).end()
-              .end()
  }
  return next()
diff --git a/server/middlewares/validators/activitypub/pagination.ts b/server/middlewares/validators/activitypub/pagination.ts
index fa21f063d..c8ec34eb6 100644
--- a/server/middlewares/validators/activitypub/pagination.ts
+++ b/server/middlewares/validators/activitypub/pagination.ts
@@ -1,8 +1,8 @@
 import * as express from 'express'
 import { query } from 'express-validator'
-import { logger } from '../../../helpers/logger'
-import { areValidationErrors } from '../utils'
 import { PAGINATION } from '@server/initializers/constants'
+import { logger } from '../../../helpers/logger'
+import { areValidationErrors } from '../shared'
 const apPaginationValidator = [
  query('page')
diff --git a/server/middlewares/validators/activitypub/signature.ts b/server/middlewares/validators/activitypub/signature.ts
index 7c4e49463..f2f7d5848 100644
--- a/server/middlewares/validators/activitypub/signature.ts
+++ b/server/middlewares/validators/activitypub/signature.ts
@@ -1,12 +1,13 @@
 import * as express from 'express'
 import { body } from 'express-validator'
 import {
-  isSignatureCreatorValid, isSignatureTypeValid,
+  isSignatureCreatorValid,
+  isSignatureTypeValid,
  isSignatureValueValid
 } from '../../../helpers/custom-validators/activitypub/signature'
 import { isDateValid } from '../../../helpers/custom-validators/misc'
 import { logger } from '../../../helpers/logger'
-import { areValidationErrors } from '../utils'
+import { areValidationErrors } from '../shared'
 const signatureValidator = [
  body('signature.type')
@@ -14,7 +15,7 @@ const signatureValidator = [
    .custom(isSignatureTypeValid).withMessage('Should have a valid signature type'),
  body('signature.created')
    .optional()
-    .custom(isDateValid).withMessage('Should have a valid signature created date'),
+    .custom(isDateValid).withMessage('Should have a signature created date that conforms to ISO 8601'),
  body('signature.creator')
    .optional()
    .custom(isSignatureCreatorValid).withMessage('Should have a valid signature creator'),
diff --git a/server/middlewares/validators/actor-image.ts b/server/middlewares/validators/actor-image.ts
index 961d7a7e5..49daadd61 100644
--- a/server/middlewares/validators/actor-image.ts
+++ b/server/middlewares/validators/actor-image.ts
@@ -4,7 +4,7 @@ import { isActorImageFile } from '@server/helpers/custom-validators/actor-images
 import { cleanUpReqFiles } from '../../helpers/express-utils'
 import { logger } from '../../helpers/logger'
 import { CONSTRAINTS_FIELDS } from '../../initializers/constants'
-import { areValidationErrors } from './utils'
+import { areValidationErrors } from './shared'
 const updateActorImageValidatorFactory = (fieldname: string) => ([
  body(fieldname).custom((value, { req }) => isActorImageFile(req.files, fieldname)).withMessage(
diff --git a/server/middlewares/validators/blocklist.ts b/server/middlewares/validators/blocklist.ts
index f61811a1a..826b16fc8 100644
--- a/server/middlewares/validators/blocklist.ts
+++ b/server/middlewares/validators/blocklist.ts
@@ -1,15 +1,14 @@
-import { body, param } from 'express-validator'
 import * as express from 'express'
+import { body, param } from 'express-validator'
+import { getServerActor } from '@server/models/application/application'
+import { HttpStatusCode } from '../../../shared/core-utils/miscs/http-error-codes'
+import { isHostValid } from '../../helpers/custom-validators/servers'
 import { logger } from '../../helpers/logger'
-import { areValidationErrors } from './utils'
+import { WEBSERVER } from '../../initializers/constants'
 import { AccountBlocklistModel } from '../../models/account/account-blocklist'
-import { isHostValid } from '../../helpers/custom-validators/servers'
-import { ServerBlocklistModel } from '../../models/server/server-blocklist'
 import { ServerModel } from '../../models/server/server'
-import { WEBSERVER } from '../../initializers/constants'
+import { ServerBlocklistModel } from '../../models/server/server-blocklist'
-import { doesAccountNameWithHostExist } from '../../helpers/middlewares'
+import { areValidationErrors, doesAccountNameWithHostExist } from './shared'
-import { getServerActor } from '@server/models/application/application'
-import { HttpStatusCode } from '../../../shared/core-utils/miscs/http-error-codes'
 const blockAccountValidator = [
  body('accountName').exists().withMessage('Should have an account name with host'),
@@ -24,9 +23,10 @@ const blockAccountValidator = [
    const accountToBlock = res.locals.account
    if (user.Account.id === accountToBlock.id) {
-      res.status(HttpStatusCode.CONFLICT_409)
+      res.fail({
-         .json({ error: 'You cannot block yourself.' })
+        status: HttpStatusCode.CONFLICT_409,
+        message: 'You cannot block yourself.'
+      })
      return
    }
@@ -79,8 +79,10 @@ const blockServerValidator = [
    const host: string = req.body.host
    if (host === WEBSERVER.HOST) {
-      return res.status(HttpStatusCode.CONFLICT_409)
+      return res.fail({
-        .json({ error: 'You cannot block your own server.' })
+        status: HttpStatusCode.CONFLICT_409,
+        message: 'You cannot block your own server.'
+      })
    }
    const server = await ServerModel.loadOrCreateByHost(host)
@@ -137,27 +139,27 @@ export {
 async function doesUnblockAccountExist (accountId: number, targetAccountId: number, res: express.Response) {
  const accountBlock = await AccountBlocklistModel.loadByAccountAndTarget(accountId, targetAccountId)
  if (!accountBlock) {
-    res.status(HttpStatusCode.NOT_FOUND_404)
+    res.fail({
-       .json({ error: 'Account block entry not found.' })
+      status: HttpStatusCode.NOT_FOUND_404,
+      message: 'Account block entry not found.'
+    })
    return false
  }
  res.locals.accountBlock = accountBlock
  return true
 }
 async function doesUnblockServerExist (accountId: number, host: string, res: express.Response) {
  const serverBlock = await ServerBlocklistModel.loadByAccountAndHost(accountId, host)
  if (!serverBlock) {
-    res.status(HttpStatusCode.NOT_FOUND_404)
+    res.fail({
-       .json({ error: 'Server block entry not found.' })
+      status: HttpStatusCode.NOT_FOUND_404,
+      message: 'Server block entry not found.'
+    })
    return false
  }
  res.locals.serverBlock = serverBlock
  return true
 }
diff --git a/server/middlewares/validators/bulk.ts b/server/middlewares/validators/bulk.ts
index cfb16d352..9bb95f5b7 100644
--- a/server/middlewares/validators/bulk.ts
+++ b/server/middlewares/validators/bulk.ts
@@ -1,12 +1,11 @@
 import * as express from 'express'
 import { body } from 'express-validator'
 import { isBulkRemoveCommentsOfScopeValid } from '@server/helpers/custom-validators/bulk'
-import { doesAccountNameWithHostExist } from '@server/helpers/middlewares'
+import { HttpStatusCode } from '@shared/core-utils/miscs/http-error-codes'
 import { UserRight } from '@shared/models'
 import { BulkRemoveCommentsOfBody } from '@shared/models/bulk/bulk-remove-comments-of-body.model'
 import { logger } from '../../helpers/logger'
-import { areValidationErrors } from './utils'
+import { areValidationErrors, doesAccountNameWithHostExist } from './shared'
-import { HttpStatusCode } from '@shared/core-utils/miscs/http-error-codes'
 const bulkRemoveCommentsOfValidator = [
  body('accountName').exists().withMessage('Should have an account name with host'),
@@ -23,9 +22,9 @@ const bulkRemoveCommentsOfValidator = [
    const body = req.body as BulkRemoveCommentsOfBody
    if (body.scope === 'instance' && user.hasRight(UserRight.REMOVE_ANY_VIDEO_COMMENT) !== true) {
-      return res.status(HttpStatusCode.FORBIDDEN_403)
+      return res.fail({
-      .json({
+        status: HttpStatusCode.FORBIDDEN_403,
-        error: 'User cannot remove any comments of this instance.'
+        message: 'User cannot remove any comments of this instance.'
      })
    }
diff --git a/server/middlewares/validators/config.ts b/server/middlewares/validators/config.ts
index a85883b19..1aeadbe65 100644
--- a/server/middlewares/validators/config.ts
+++ b/server/middlewares/validators/config.ts
@@ -2,13 +2,12 @@ import * as express from 'express'
 import { body } from 'express-validator'
 import { isIntOrNull } from '@server/helpers/custom-validators/misc'
 import { isEmailEnabled } from '@server/initializers/config'
-import { HttpStatusCode } from '../../../shared/core-utils/miscs/http-error-codes'
 import { CustomConfig } from '../../../shared/models/server/custom-config.model'
 import { isThemeNameValid } from '../../helpers/custom-validators/plugins'
 import { isUserNSFWPolicyValid, isUserVideoQuotaDailyValid, isUserVideoQuotaValid } from '../../helpers/custom-validators/users'
 import { logger } from '../../helpers/logger'
 import { isThemeRegistered } from '../../lib/plugins/theme-utils'
-import { areValidationErrors } from './utils'
+import { areValidationErrors } from './shared'
 const customConfigUpdateValidator = [
  body('instance.name').exists().withMessage('Should have a valid instance name'),
@@ -30,6 +29,7 @@ const customConfigUpdateValidator = [
  body('signup.enabled').isBoolean().withMessage('Should have a valid signup enabled boolean'),
  body('signup.limit').isInt().withMessage('Should have a valid signup limit'),
  body('signup.requiresEmailVerification').isBoolean().withMessage('Should have a valid requiresEmailVerification boolean'),
+  body('signup.minimumAge').isInt().withMessage("Should have a valid minimum age required"),
  body('admin.email').isEmail().withMessage('Should have a valid administrator email'),
  body('contactForm.enabled').isBoolean().withMessage('Should have a valid contact form enabled boolean'),
@@ -114,9 +114,7 @@ function checkInvalidConfigIfEmailDisabled (customConfig: CustomConfig, res: exp
  if (isEmailEnabled()) return true
  if (customConfig.signup.requiresEmailVerification === true) {
-    res.status(HttpStatusCode.BAD_REQUEST_400)
+    res.fail({ message: 'Emailer is disabled but you require signup email verification.' })
-       .send({ error: 'Emailer is disabled but you require signup email verification.' })
-       .end()
    return false
  }
@@ -127,9 +125,7 @@ function checkInvalidTranscodingConfig (customConfig: CustomConfig, res: express
  if (customConfig.transcoding.enabled === false) return true
  if (customConfig.transcoding.webtorrent.enabled === false && customConfig.transcoding.hls.enabled === false) {
-    res.status(HttpStatusCode.BAD_REQUEST_400)
+    res.fail({ message: 'You need to enable at least webtorrent transcoding or hls transcoding' })
-       .send({ error: 'You need to enable at least webtorrent transcoding or hls transcoding' })
-       .end()
    return false
  }
@@ -140,9 +136,7 @@ function checkInvalidLiveConfig (customConfig: CustomConfig, res: express.Respon
  if (customConfig.live.enabled === false) return true
  if (customConfig.live.allowReplay === true && customConfig.transcoding.enabled === false) {
-    res.status(HttpStatusCode.BAD_REQUEST_400)
+    res.fail({ message: 'You cannot allow live replay if transcoding is not enabled' })
-       .send({ error: 'You cannot allow live replay if transcoding is not enabled' })
-       .end()
    return false
  }
diff --git a/server/middlewares/validators/feeds.ts b/server/middlewares/validators/feeds.ts
index 617661813..51b8fdd19 100644
--- a/server/middlewares/validators/feeds.ts
+++ b/server/middlewares/validators/feeds.ts
@@ -1,18 +1,19 @@
 import * as express from 'express'
 import { param, query } from 'express-validator'
+import { HttpStatusCode } from '../../../shared/core-utils/miscs/http-error-codes'
 import { isValidRSSFeed } from '../../helpers/custom-validators/feeds'
-import { exists, isIdOrUUIDValid, isIdValid } from '../../helpers/custom-validators/misc'
+import { exists, isIdOrUUIDValid, isIdValid, toCompleteUUID } from '../../helpers/custom-validators/misc'
 import { logger } from '../../helpers/logger'
 import {
+  areValidationErrors,
  doesAccountIdExist,
  doesAccountNameWithHostExist,
  doesUserFeedTokenCorrespond,
  doesVideoChannelIdExist,
-  doesVideoChannelNameWithHostExist
+  doesVideoChannelNameWithHostExist,
-} from '../../helpers/middlewares'
+  doesVideoExist
-import { doesVideoExist } from '../../helpers/middlewares/videos'
+} from './shared'
-import { areValidationErrors } from './utils'
-import { HttpStatusCode } from '../../../shared/core-utils/miscs/http-error-codes'
 const feedsFormatValidator = [
  param('format').optional().custom(isValidRSSFeed).withMessage('Should have a valid format (rss, atom, json)'),
@@ -36,10 +37,10 @@ function setFeedFormatContentType (req: express.Request, res: express.Response,
  if (req.accepts(acceptableContentTypes)) {
    res.set('Content-Type', req.accepts(acceptableContentTypes) as string)
  } else {
-    return res.status(HttpStatusCode.NOT_ACCEPTABLE_406)
+    return res.fail({
-              .json({
+      status: HttpStatusCode.NOT_ACCEPTABLE_406,
-                message: `You should accept at least one of the following content-types: ${acceptableContentTypes.join(', ')}`
+      message: `You should accept at least one of the following content-types: ${acceptableContentTypes.join(', ')}`
-              })
+    })
  }
  return next()
@@ -98,7 +99,10 @@ const videoSubscriptionFeedsValidator = [
 ]
 const videoCommentsFeedsValidator = [
-  query('videoId').optional().custom(isIdOrUUIDValid),
+  query('videoId')
+    .customSanitizer(toCompleteUUID)
+    .optional()
+    .custom(isIdOrUUIDValid),
  async (req: express.Request, res: express.Response, next: express.NextFunction) => {
    logger.debug('Checking feeds parameters', { parameters: req.query })
@@ -106,10 +110,7 @@ const videoCommentsFeedsValidator = [
    if (areValidationErrors(req, res)) return
    if (req.query.videoId && (req.query.videoChannelId || req.query.videoChannelName)) {
-      return res.status(HttpStatusCode.BAD_REQUEST_400)
+      return res.fail({ message: 'videoId cannot be mixed with a channel filter' })
-                .json({
-                  message: 'videoId cannot be mixed with a channel filter'
-                })
    }
    if (req.query.videoId && !await doesVideoExist(req.query.videoId, res)) return
diff --git a/server/middlewares/validators/follows.ts b/server/middlewares/validators/follows.ts
index bb849dc72..205baca48 100644
--- a/server/middlewares/validators/follows.ts
+++ b/server/middlewares/validators/follows.ts
@@ -1,18 +1,18 @@
 import * as express from 'express'
 import { body, param, query } from 'express-validator'
+import { isFollowStateValid } from '@server/helpers/custom-validators/follows'
+import { loadActorUrlOrGetFromWebfinger } from '@server/lib/activitypub/actors'
+import { getServerActor } from '@server/models/application/application'
+import { MActorFollowActorsDefault } from '@server/types/models'
+import { HttpStatusCode } from '../../../shared/core-utils/miscs/http-error-codes'
 import { isTestInstance } from '../../helpers/core-utils'
+import { isActorTypeValid, isValidActorHandle } from '../../helpers/custom-validators/activitypub/actor'
 import { isEachUniqueHostValid, isHostValid } from '../../helpers/custom-validators/servers'
 import { logger } from '../../helpers/logger'
 import { SERVER_ACTOR_NAME, WEBSERVER } from '../../initializers/constants'
-import { ActorFollowModel } from '../../models/activitypub/actor-follow'
+import { ActorModel } from '../../models/actor/actor'
-import { areValidationErrors } from './utils'
+import { ActorFollowModel } from '../../models/actor/actor-follow'
-import { ActorModel } from '../../models/activitypub/actor'
+import { areValidationErrors } from './shared'
-import { loadActorUrlOrGetFromWebfinger } from '../../helpers/webfinger'
-import { isActorTypeValid, isValidActorHandle } from '../../helpers/custom-validators/activitypub/actor'
-import { MActorFollowActorsDefault } from '@server/types/models'
-import { isFollowStateValid } from '@server/helpers/custom-validators/follows'
-import { getServerActor } from '@server/models/application/application'
-import { HttpStatusCode } from '../../../shared/core-utils/miscs/http-error-codes'
 const listFollowsValidator = [
  query('state')
@@ -63,11 +63,10 @@ const removeFollowingValidator = [
    const follow = await ActorFollowModel.loadByActorAndTargetNameAndHostForAPI(serverActor.id, SERVER_ACTOR_NAME, req.params.host)
    if (!follow) {
-      return res
+      return res.fail({
-        .status(HttpStatusCode.NOT_FOUND_404)
+        status: HttpStatusCode.NOT_FOUND_404,
-        .json({
+        message: `Following ${req.params.host} not found.`
-          error: `Following ${req.params.host} not found.`
+      })
-        })
    }
    res.locals.follow = follow
@@ -95,12 +94,10 @@ const getFollowerValidator = [
    }
    if (!follow) {
-      return res
+      return res.fail({
-        .status(HttpStatusCode.NOT_FOUND_404)
+        status: HttpStatusCode.NOT_FOUND_404,
-        .json({
+        message: `Follower ${req.params.nameWithHost} not found.`
-          error: `Follower ${req.params.nameWithHost} not found.`
+      })
-        })
-        .end()
    }
    res.locals.follow = follow
@@ -114,12 +111,7 @@ const acceptOrRejectFollowerValidator = [
    const follow = res.locals.follow
    if (follow.state !== 'pending') {
-      return res
+      return res.fail({ message: 'Follow is not in pending state.' })
-        .status(HttpStatusCode.BAD_REQUEST_400)
-        .json({
-          error: 'Follow is not in pending state.'
-        })
-        .end()
    }
    return next()
diff --git a/server/middlewares/validators/index.ts b/server/middlewares/validators/index.ts
index 24faeea3e..94a3c2dea 100644
--- a/server/middlewares/validators/index.ts
+++ b/server/middlewares/validators/index.ts
@@ -11,7 +11,7 @@ export * from './sort'
 export * from './users'
 export * from './user-subscriptions'
 export * from './videos'
-export * from './webfinger'
 export * from './search'
 export * from './server'
 export * from './user-history'
+export * from './webfinger'
diff --git a/server/middlewares/validators/jobs.ts b/server/middlewares/validators/jobs.ts
index d87b28c06..5d89d167f 100644
--- a/server/middlewares/validators/jobs.ts
+++ b/server/middlewares/validators/jobs.ts
@@ -2,7 +2,7 @@ import * as express from 'express'
 import { param, query } from 'express-validator'
 import { isValidJobState, isValidJobType } from '../../helpers/custom-validators/jobs'
 import { logger, loggerTagsFactory } from '../../helpers/logger'
-import { areValidationErrors } from './utils'
+import { areValidationErrors } from './shared'
 const lTags = loggerTagsFactory('validators', 'jobs')
diff --git a/server/middlewares/validators/logs.ts b/server/middlewares/validators/logs.ts
index 70e4d0d99..c55baaee3 100644
--- a/server/middlewares/validators/logs.ts
+++ b/server/middlewares/validators/logs.ts
@@ -1,19 +1,19 @@
 import * as express from 'express'
-import { logger } from '../../helpers/logger'
-import { areValidationErrors } from './utils'
-import { isDateValid } from '../../helpers/custom-validators/misc'
 import { query } from 'express-validator'
 import { isValidLogLevel } from '../../helpers/custom-validators/logs'
+import { isDateValid } from '../../helpers/custom-validators/misc'
+import { logger } from '../../helpers/logger'
+import { areValidationErrors } from './shared'
 const getLogsValidator = [
  query('startDate')
-    .custom(isDateValid).withMessage('Should have a valid start date'),
+    .custom(isDateValid).withMessage('Should have a start date that conforms to ISO 8601'),
  query('level')
    .optional()
    .custom(isValidLogLevel).withMessage('Should have a valid level'),
  query('endDate')
    .optional()
-    .custom(isDateValid).withMessage('Should have a valid end date'),
+    .custom(isDateValid).withMessage('Should have an end date that conforms to ISO 8601'),
  (req: express.Request, res: express.Response, next: express.NextFunction) => {
    logger.debug('Checking getLogsValidator parameters.', { parameters: req.query })
@@ -26,10 +26,10 @@ const getLogsValidator = [
 const getAuditLogsValidator = [
  query('startDate')
-    .custom(isDateValid).withMessage('Should have a valid start date'),
+    .custom(isDateValid).withMessage('Should have a start date that conforms to ISO 8601'),
  query('endDate')
    .optional()
-    .custom(isDateValid).withMessage('Should have a valid end date'),
+    .custom(isDateValid).withMessage('Should have a end date that conforms to ISO 8601'),
  (req: express.Request, res: express.Response, next: express.NextFunction) => {
    logger.debug('Checking getAuditLogsValidator parameters.', { parameters: req.query })
diff --git a/server/middlewares/validators/oembed.ts b/server/middlewares/validators/oembed.ts
index 2a7dc257b..0a82e6932 100644
--- a/server/middlewares/validators/oembed.ts
+++ b/server/middlewares/validators/oembed.ts
@@ -1,18 +1,32 @@
 import * as express from 'express'
 import { query } from 'express-validator'
 import { join } from 'path'
-import { fetchVideo } from '@server/helpers/video'
+import { loadVideo } from '@server/lib/model-loaders'
 import { VideoPlaylistModel } from '@server/models/video/video-playlist'
 import { VideoPlaylistPrivacy, VideoPrivacy } from '@shared/models'
+import { HttpStatusCode } from '../../../shared/core-utils/miscs/http-error-codes'
 import { isTestInstance } from '../../helpers/core-utils'
-import { isIdOrUUIDValid } from '../../helpers/custom-validators/misc'
+import { isIdOrUUIDValid, toCompleteUUID } from '../../helpers/custom-validators/misc'
 import { logger } from '../../helpers/logger'
 import { WEBSERVER } from '../../initializers/constants'
-import { areValidationErrors } from './utils'
+import { areValidationErrors } from './shared'
-import { HttpStatusCode } from '../../../shared/core-utils/miscs/http-error-codes'
+const playlistPaths = [
+  join('videos', 'watch', 'playlist'),
+  join('w', 'p')
+]
+const videoPaths = [
+  join('videos', 'watch'),
+  'w'
+]
+function buildUrls (paths: string[]) {
+  return paths.map(p => WEBSERVER.SCHEME + '://' + join(WEBSERVER.HOST, p) + '/')
+}
-const startVideoPlaylistsURL = WEBSERVER.SCHEME + '://' + join(WEBSERVER.HOST, 'videos', 'watch', 'playlist') + '/'
+const startPlaylistURLs = buildUrls(playlistPaths)
-const startVideosURL = WEBSERVER.SCHEME + '://' + join(WEBSERVER.HOST, 'videos', 'watch') + '/'
+const startVideoURLs = buildUrls(videoPaths)
 const watchRegex = /([^/]+)$/
 const isURLOptions = {
@@ -37,41 +51,54 @@ const oembedValidator = [
    if (areValidationErrors(req, res)) return
    if (req.query.format !== undefined && req.query.format !== 'json') {
-      return res.status(HttpStatusCode.NOT_IMPLEMENTED_501)
+      return res.fail({
-        .json({ error: 'Requested format is not implemented on server.' })
+        status: HttpStatusCode.NOT_IMPLEMENTED_501,
+        message: 'Requested format is not implemented on server.',
+        data: {
+          format: req.query.format
+        }
+      })
    }
    const url = req.query.url as string
-    const isPlaylist = url.startsWith(startVideoPlaylistsURL)
+    const isPlaylist = startPlaylistURLs.some(u => url.startsWith(u))
-    const isVideo = isPlaylist ? false : url.startsWith(startVideosURL)
+    const isVideo = isPlaylist ? false : startVideoURLs.some(u => url.startsWith(u))
    const startIsOk = isVideo || isPlaylist
    const matches = watchRegex.exec(url)
    if (startIsOk === false || matches === null) {
-      return res.status(HttpStatusCode.BAD_REQUEST_400)
+      return res.fail({
-        .json({ error: 'Invalid url.' })
+        status: HttpStatusCode.BAD_REQUEST_400,
+        message: 'Invalid url.',
+        data: {
+          url
+        }
+      })
    }
-    const elementId = matches[1]
+    const elementId = toCompleteUUID(matches[1])
    if (isIdOrUUIDValid(elementId) === false) {
-      return res.status(HttpStatusCode.BAD_REQUEST_400)
+      return res.fail({ message: 'Invalid video or playlist id.' })
-        .json({ error: 'Invalid video or playlist id.' })
    }
    if (isVideo) {
-      const video = await fetchVideo(elementId, 'all')
+      const video = await loadVideo(elementId, 'all')
      if (!video) {
-        return res.status(HttpStatusCode.NOT_FOUND_404)
+        return res.fail({
-          .json({ error: 'Video not found' })
+          status: HttpStatusCode.NOT_FOUND_404,
+          message: 'Video not found'
+        })
      }
      if (video.privacy !== VideoPrivacy.PUBLIC) {
-        return res.status(HttpStatusCode.FORBIDDEN_403)
+        return res.fail({
-          .json({ error: 'Video is not public' })
+          status: HttpStatusCode.FORBIDDEN_403,
+          message: 'Video is not public'
+        })
      }
      res.locals.videoAll = video
@@ -82,13 +109,17 @@ const oembedValidator = [
    const videoPlaylist = await VideoPlaylistModel.loadWithAccountAndChannelSummary(elementId, undefined)
    if (!videoPlaylist) {
-      return res.status(HttpStatusCode.NOT_FOUND_404)
+      return res.fail({
-        .json({ error: 'Video playlist not found' })
+        status: HttpStatusCode.NOT_FOUND_404,
+        message: 'Video playlist not found'
+      })
    }
    if (videoPlaylist.privacy !== VideoPlaylistPrivacy.PUBLIC) {
-      return res.status(HttpStatusCode.FORBIDDEN_403)
+      return res.fail({
-        .json({ error: 'Playlist is not public' })
+        status: HttpStatusCode.FORBIDDEN_403,
+        message: 'Playlist is not public'
+      })
    }
    res.locals.videoPlaylistSummary = videoPlaylist
diff --git a/server/middlewares/validators/pagination.ts b/server/middlewares/validators/pagination.ts
index 6b0a83d80..74eae251e 100644
--- a/server/middlewares/validators/pagination.ts
+++ b/server/middlewares/validators/pagination.ts
@@ -1,8 +1,8 @@
 import * as express from 'express'
 import { query } from 'express-validator'
-import { logger } from '../../helpers/logger'
-import { areValidationErrors } from './utils'
 import { PAGINATION } from '@server/initializers/constants'
+import { logger } from '../../helpers/logger'
+import { areValidationErrors } from './shared'
 const paginationValidator = paginationValidatorBuilder()
diff --git a/server/middlewares/validators/plugins.ts b/server/middlewares/validators/plugins.ts
index ab87fe720..8c76d2e36 100644
--- a/server/middlewares/validators/plugins.ts
+++ b/server/middlewares/validators/plugins.ts
@@ -1,15 +1,15 @@
 import * as express from 'express'
 import { body, param, query, ValidationChain } from 'express-validator'
-import { logger } from '../../helpers/logger'
+import { HttpStatusCode } from '../../../shared/core-utils/miscs/http-error-codes'
-import { areValidationErrors } from './utils'
+import { PluginType } from '../../../shared/models/plugins/plugin.type'
+import { InstallOrUpdatePlugin } from '../../../shared/models/plugins/server/api/install-plugin.model'
+import { exists, isBooleanValid, isSafePath, toBooleanOrNull, toIntOrNull } from '../../helpers/custom-validators/misc'
 import { isNpmPluginNameValid, isPluginNameValid, isPluginTypeValid, isPluginVersionValid } from '../../helpers/custom-validators/plugins'
+import { logger } from '../../helpers/logger'
+import { CONFIG } from '../../initializers/config'
 import { PluginManager } from '../../lib/plugins/plugin-manager'
-import { isBooleanValid, isSafePath, toBooleanOrNull, exists, toIntOrNull } from '../../helpers/custom-validators/misc'
 import { PluginModel } from '../../models/server/plugin'
-import { InstallOrUpdatePlugin } from '../../../shared/models/plugins/install-plugin.model'
+import { areValidationErrors } from './shared'
-import { PluginType } from '../../../shared/models/plugins/plugin.type'
-import { CONFIG } from '../../initializers/config'
-import { HttpStatusCode } from '../../../shared/core-utils/miscs/http-error-codes'
 const getPluginValidator = (pluginType: PluginType, withVersion = true) => {
  const validators: (ValidationChain | express.Handler)[] = [
@@ -31,8 +31,18 @@ const getPluginValidator = (pluginType: PluginType, withVersion = true) => {
      const npmName = PluginModel.buildNpmName(req.params.pluginName, pluginType)
      const plugin = PluginManager.Instance.getRegisteredPluginOrTheme(npmName)
-      if (!plugin) return res.sendStatus(HttpStatusCode.NOT_FOUND_404)
+      if (!plugin) {
-      if (withVersion && plugin.version !== req.params.pluginVersion) return res.sendStatus(HttpStatusCode.NOT_FOUND_404)
+        return res.fail({
+          status: HttpStatusCode.NOT_FOUND_404,
+          message: 'No plugin found named ' + npmName
+        })
+      }
+      if (withVersion && plugin.version !== req.params.pluginVersion) {
+        return res.fail({
+          status: HttpStatusCode.NOT_FOUND_404,
+          message: 'No plugin found named ' + npmName + ' with version ' + req.params.pluginVersion
+        })
+      }
      res.locals.registeredPlugin = plugin
@@ -50,10 +60,20 @@ const getExternalAuthValidator = [
    if (areValidationErrors(req, res)) return
    const plugin = res.locals.registeredPlugin
-    if (!plugin.registerHelpers) return res.sendStatus(HttpStatusCode.NOT_FOUND_404)
+    if (!plugin.registerHelpers) {
+      return res.fail({
+        status: HttpStatusCode.NOT_FOUND_404,
+        message: 'No registered helpers were found for this plugin'
+      })
+    }
    const externalAuth = plugin.registerHelpers.getExternalAuths().find(a => a.authName === req.params.authName)
-    if (!externalAuth) return res.sendStatus(HttpStatusCode.NOT_FOUND_404)
+    if (!externalAuth) {
+      return res.fail({
+        status: HttpStatusCode.NOT_FOUND_404,
+        message: 'No external auths were found for this plugin'
+      })
+    }
    res.locals.externalAuth = externalAuth
@@ -107,8 +127,7 @@ const installOrUpdatePluginValidator = [
    const body: InstallOrUpdatePlugin = req.body
    if (!body.path && !body.npmName) {
-      return res.status(HttpStatusCode.BAD_REQUEST_400)
+      return res.fail({ message: 'Should have either a npmName or a path' })
-                .json({ error: 'Should have either a npmName or a path' })
    }
    return next()
@@ -137,12 +156,13 @@ const existingPluginValidator = [
    const plugin = await PluginModel.loadByNpmName(req.params.npmName)
    if (!plugin) {
-      return res.status(HttpStatusCode.NOT_FOUND_404)
+      return res.fail({
-                .json({ error: 'Plugin not found' })
+        status: HttpStatusCode.NOT_FOUND_404,
+        message: 'Plugin not found'
+      })
    }
    res.locals.plugin = plugin
    return next()
  }
 ]
@@ -177,9 +197,7 @@ const listAvailablePluginsValidator = [
    if (areValidationErrors(req, res)) return
    if (CONFIG.PLUGINS.INDEX.ENABLED === false) {
-      return res.status(HttpStatusCode.BAD_REQUEST_400)
+      return res.fail({ message: 'Plugin index is not enabled' })
-                .json({ error: 'Plugin index is not enabled' })
-                .end()
    }
    return next()
diff --git a/server/middlewares/validators/redundancy.ts b/server/middlewares/validators/redundancy.ts
index c379aebe4..116c8c611 100644
--- a/server/middlewares/validators/redundancy.ts
+++ b/server/middlewares/validators/redundancy.ts
@@ -1,17 +1,25 @@
 import * as express from 'express'
 import { body, param, query } from 'express-validator'
-import { exists, isBooleanValid, isIdOrUUIDValid, isIdValid, toBooleanOrNull, toIntOrNull } from '../../helpers/custom-validators/misc'
+import { isVideoRedundancyTarget } from '@server/helpers/custom-validators/video-redundancies'
+import { HttpStatusCode } from '../../../shared/core-utils/miscs/http-error-codes'
+import {
+  exists,
+  isBooleanValid,
+  isIdOrUUIDValid,
+  isIdValid,
+  toBooleanOrNull,
+  toCompleteUUID,
+  toIntOrNull
+} from '../../helpers/custom-validators/misc'
+import { isHostValid } from '../../helpers/custom-validators/servers'
 import { logger } from '../../helpers/logger'
-import { areValidationErrors } from './utils'
 import { VideoRedundancyModel } from '../../models/redundancy/video-redundancy'
-import { isHostValid } from '../../helpers/custom-validators/servers'
 import { ServerModel } from '../../models/server/server'
-import { doesVideoExist } from '../../helpers/middlewares'
+import { areValidationErrors, doesVideoExist, isValidVideoIdParam } from './shared'
-import { isVideoRedundancyTarget } from '@server/helpers/custom-validators/video-redundancies'
-import { HttpStatusCode } from '../../../shared/core-utils/miscs/http-error-codes'
 const videoFileRedundancyGetValidator = [
-  param('videoId').custom(isIdOrUUIDValid).not().isEmpty().withMessage('Should have a valid video id'),
+  isValidVideoIdParam('videoId'),
  param('resolution')
    .customSanitizer(toIntOrNull)
    .custom(exists).withMessage('Should have a valid resolution'),
@@ -35,11 +43,21 @@ const videoFileRedundancyGetValidator = [
      return f.resolution === paramResolution && (!req.params.fps || paramFPS)
    })
-    if (!videoFile) return res.status(HttpStatusCode.NOT_FOUND_404).json({ error: 'Video file not found.' })
+    if (!videoFile) {
+      return res.fail({
+        status: HttpStatusCode.NOT_FOUND_404,
+        message: 'Video file not found.'
+      })
+    }
    res.locals.videoFile = videoFile
    const videoRedundancy = await VideoRedundancyModel.loadLocalByFileId(videoFile.id)
-    if (!videoRedundancy) return res.status(HttpStatusCode.NOT_FOUND_404).json({ error: 'Video redundancy not found.' })
+    if (!videoRedundancy) {
+      return res.fail({
+        status: HttpStatusCode.NOT_FOUND_404,
+        message: 'Video redundancy not found.'
+      })
+    }
    res.locals.videoRedundancy = videoRedundancy
    return next()
@@ -47,9 +65,8 @@ const videoFileRedundancyGetValidator = [
 ]
 const videoPlaylistRedundancyGetValidator = [
-  param('videoId')
+  isValidVideoIdParam('videoId'),
-    .custom(isIdOrUUIDValid)
-    .not().isEmpty().withMessage('Should have a valid video id'),
  param('streamingPlaylistType')
    .customSanitizer(toIntOrNull)
    .custom(exists).withMessage('Should have a valid streaming playlist type'),
@@ -65,11 +82,21 @@ const videoPlaylistRedundancyGetValidator = [
    const paramPlaylistType = req.params.streamingPlaylistType as unknown as number // We casted to int above
    const videoStreamingPlaylist = video.VideoStreamingPlaylists.find(p => p.type === paramPlaylistType)
-    if (!videoStreamingPlaylist) return res.status(HttpStatusCode.NOT_FOUND_404).json({ error: 'Video playlist not found.' })
+    if (!videoStreamingPlaylist) {
+      return res.fail({
+        status: HttpStatusCode.NOT_FOUND_404,
+        message: 'Video playlist not found.'
+      })
+    }
    res.locals.videoStreamingPlaylist = videoStreamingPlaylist
    const videoRedundancy = await VideoRedundancyModel.loadLocalByStreamingPlaylistId(videoStreamingPlaylist.id)
-    if (!videoRedundancy) return res.status(HttpStatusCode.NOT_FOUND_404).json({ error: 'Video redundancy not found.' })
+    if (!videoRedundancy) {
+      return res.fail({
+        status: HttpStatusCode.NOT_FOUND_404,
+        message: 'Video redundancy not found.'
+      })
+    }
    res.locals.videoRedundancy = videoRedundancy
    return next()
@@ -90,12 +117,10 @@ const updateServerRedundancyValidator = [
    const server = await ServerModel.loadByHost(req.params.host)
    if (!server) {
-      return res
+      return res.fail({
-        .status(HttpStatusCode.NOT_FOUND_404)
+        status: HttpStatusCode.NOT_FOUND_404,
-        .json({
+        message: `Server ${req.params.host} not found.`
-          error: `Server ${req.params.host} not found.`
+      })
-        })
-        .end()
    }
    res.locals.server = server
@@ -118,7 +143,8 @@ const listVideoRedundanciesValidator = [
 const addVideoRedundancyValidator = [
  body('videoId')
-    .custom(isIdValid)
+    .customSanitizer(toCompleteUUID)
+    .custom(isIdOrUUIDValid)
    .withMessage('Should have a valid video id'),
  async (req: express.Request, res: express.Response, next: express.NextFunction) => {
@@ -129,19 +155,19 @@ const addVideoRedundancyValidator = [
    if (!await doesVideoExist(req.body.videoId, res, 'only-video')) return
    if (res.locals.onlyVideo.remote === false) {
-      return res.status(HttpStatusCode.BAD_REQUEST_400)
+      return res.fail({ message: 'Cannot create a redundancy on a local video' })
-        .json({ error: 'Cannot create a redundancy on a local video' })
    }
    if (res.locals.onlyVideo.isLive) {
-      return res.status(HttpStatusCode.BAD_REQUEST_400)
+      return res.fail({ message: 'Cannot create a redundancy of a live video' })
-        .json({ error: 'Cannot create a redundancy of a live video' })
    }
    const alreadyExists = await VideoRedundancyModel.isLocalByVideoUUIDExists(res.locals.onlyVideo.uuid)
    if (alreadyExists) {
-      return res.status(HttpStatusCode.CONFLICT_409)
+      return res.fail({
-                .json({ error: 'This video is already duplicated by your instance.' })
+        status: HttpStatusCode.CONFLICT_409,
+        message: 'This video is already duplicated by your instance.'
+      })
    }
    return next()
@@ -160,9 +186,10 @@ const removeVideoRedundancyValidator = [
    const redundancy = await VideoRedundancyModel.loadByIdWithVideo(parseInt(req.params.redundancyId, 10))
    if (!redundancy) {
-      return res.status(HttpStatusCode.NOT_FOUND_404)
+      return res.fail({
-                .json({ error: 'Video redundancy not found' })
+        status: HttpStatusCode.NOT_FOUND_404,
-                .end()
+        message: 'Video redundancy not found'
+      })
    }
    res.locals.videoRedundancy = redundancy
diff --git a/server/middlewares/validators/search.ts b/server/middlewares/validators/search.ts
index 78213c70d..7bbf81048 100644
--- a/server/middlewares/validators/search.ts
+++ b/server/middlewares/validators/search.ts
@@ -1,18 +1,26 @@
 import * as express from 'express'
-import { areValidationErrors } from './utils'
-import { logger } from '../../helpers/logger'
 import { query } from 'express-validator'
-import { isDateValid } from '../../helpers/custom-validators/misc'
 import { isSearchTargetValid } from '@server/helpers/custom-validators/search'
+import { isDateValid } from '../../helpers/custom-validators/misc'
+import { logger } from '../../helpers/logger'
+import { areValidationErrors } from './shared'
 const videosSearchValidator = [
  query('search').optional().not().isEmpty().withMessage('Should have a valid search'),
-  query('startDate').optional().custom(isDateValid).withMessage('Should have a valid start date'),
+  query('startDate')
-  query('endDate').optional().custom(isDateValid).withMessage('Should have a valid end date'),
+    .optional()
+    .custom(isDateValid).withMessage('Should have a start date that conforms to ISO 8601'),
+  query('endDate')
+    .optional()
+    .custom(isDateValid).withMessage('Should have a end date that conforms to ISO 8601'),
-  query('originallyPublishedStartDate').optional().custom(isDateValid).withMessage('Should have a valid published start date'),
+  query('originallyPublishedStartDate')
-  query('originallyPublishedEndDate').optional().custom(isDateValid).withMessage('Should have a valid published end date'),
+    .optional()
+    .custom(isDateValid).withMessage('Should have a published start date that conforms to ISO 8601'),
+  query('originallyPublishedEndDate')
+    .optional()
+    .custom(isDateValid).withMessage('Should have a published end date that conforms to ISO 8601'),
  query('durationMin').optional().isInt().withMessage('Should have a valid min duration'),
  query('durationMax').optional().isInt().withMessage('Should have a valid max duration'),
@@ -41,11 +49,12 @@ const videoChannelsListSearchValidator = [
  }
 ]
-const videoChannelsOwnSearchValidator = [
+const videoPlaylistsListSearchValidator = [
-  query('search').optional().not().isEmpty().withMessage('Should have a valid search'),
+  query('search').not().isEmpty().withMessage('Should have a valid search'),
+  query('searchTarget').optional().custom(isSearchTargetValid).withMessage('Should have a valid search target'),
  (req: express.Request, res: express.Response, next: express.NextFunction) => {
-    logger.debug('Checking video channels search query', { parameters: req.query })
+    logger.debug('Checking video playlists search query', { parameters: req.query })
    if (areValidationErrors(req, res)) return
@@ -58,5 +67,5 @@ const videoChannelsOwnSearchValidator = [
 export {
  videosSearchValidator,
  videoChannelsListSearchValidator,
-  videoChannelsOwnSearchValidator
+  videoPlaylistsListSearchValidator
 }
diff --git a/server/middlewares/validators/server.ts b/server/middlewares/validators/server.ts
index fe6704716..fc7239b25 100644
--- a/server/middlewares/validators/server.ts
+++ b/server/middlewares/validators/server.ts
@@ -1,13 +1,13 @@
 import * as express from 'express'
-import { logger } from '../../helpers/logger'
-import { areValidationErrors } from './utils'
-import { isHostValid, isValidContactBody } from '../../helpers/custom-validators/servers'
-import { ServerModel } from '../../models/server/server'
 import { body } from 'express-validator'
+import { HttpStatusCode } from '../../../shared/core-utils/miscs/http-error-codes'
+import { isHostValid, isValidContactBody } from '../../helpers/custom-validators/servers'
 import { isUserDisplayNameValid } from '../../helpers/custom-validators/users'
-import { Redis } from '../../lib/redis'
+import { logger } from '../../helpers/logger'
 import { CONFIG, isEmailEnabled } from '../../initializers/config'
-import { HttpStatusCode } from '../../../shared/core-utils/miscs/http-error-codes'
+import { Redis } from '../../lib/redis'
+import { ServerModel } from '../../models/server/server'
+import { areValidationErrors } from './shared'
 const serverGetValidator = [
  body('host').custom(isHostValid).withMessage('Should have a valid host'),
@@ -19,9 +19,10 @@ const serverGetValidator = [
    const server = await ServerModel.loadByHost(req.body.host)
    if (!server) {
-      return res.status(HttpStatusCode.NOT_FOUND_404)
+      return res.fail({
-                .send({ error: 'Server host not found.' })
+        status: HttpStatusCode.NOT_FOUND_404,
-                .end()
+        message: 'Server host not found.'
+      })
    }
    res.locals.server = server
@@ -44,26 +45,26 @@ const contactAdministratorValidator = [
    if (areValidationErrors(req, res)) return
    if (CONFIG.CONTACT_FORM.ENABLED === false) {
-      return res
+      return res.fail({
-        .status(HttpStatusCode.CONFLICT_409)
+        status: HttpStatusCode.CONFLICT_409,
-        .send({ error: 'Contact form is not enabled on this instance.' })
+        message: 'Contact form is not enabled on this instance.'
-        .end()
+      })
    }
    if (isEmailEnabled() === false) {
-      return res
+      return res.fail({
-        .status(HttpStatusCode.CONFLICT_409)
+        status: HttpStatusCode.CONFLICT_409,
-        .send({ error: 'Emailer is not enabled on this instance.' })
+        message: 'Emailer is not enabled on this instance.'
-        .end()
+      })
    }
    if (await Redis.Instance.doesContactFormIpExist(req.ip)) {
      logger.info('Refusing a contact form by %s: already sent one recently.', req.ip)
-      return res
+      return res.fail({
-        .status(HttpStatusCode.FORBIDDEN_403)
+        status: HttpStatusCode.FORBIDDEN_403,
-        .send({ error: 'You already sent a contact form recently.' })
+        message: 'You already sent a contact form recently.'
-        .end()
+      })
    }
    return next()
diff --git a/server/middlewares/validators/shared/abuses.ts b/server/middlewares/validators/shared/abuses.ts
new file mode 100644
index 000000000..4a20a55fa
--- /dev/null
+++ b/server/middlewares/validators/shared/abuses.ts
@@ -0,0 +1,25 @@
+import { Response } from 'express'
+import { AbuseModel } from '@server/models/abuse/abuse'
+import { HttpStatusCode } from '@shared/core-utils'
+async function doesAbuseExist (abuseId: number | string, res: Response) {
+  const abuse = await AbuseModel.loadByIdWithReporter(parseInt(abuseId + '', 10))
+  if (!abuse) {
+    res.fail({
+      status: HttpStatusCode.NOT_FOUND_404,
+      message: 'Abuse not found'
+    })
+    return false
+  }
+  res.locals.abuse = abuse
+  return true
+}
+// ---------------------------------------------------------------------------
+export {
+  doesAbuseExist
+}
diff --git a/server/middlewares/validators/shared/accounts.ts b/server/middlewares/validators/shared/accounts.ts
new file mode 100644
index 000000000..04da15441
--- /dev/null
+++ b/server/middlewares/validators/shared/accounts.ts
@@ -0,0 +1,65 @@
+import { Response } from 'express'
+import { AccountModel } from '@server/models/account/account'
+import { UserModel } from '@server/models/user/user'
+import { MAccountDefault } from '@server/types/models'
+import { HttpStatusCode } from '@shared/core-utils'
+function doesAccountIdExist (id: number | string, res: Response, sendNotFound = true) {
+  const promise = AccountModel.load(parseInt(id + '', 10))
+  return doesAccountExist(promise, res, sendNotFound)
+}
+function doesLocalAccountNameExist (name: string, res: Response, sendNotFound = true) {
+  const promise = AccountModel.loadLocalByName(name)
+  return doesAccountExist(promise, res, sendNotFound)
+}
+function doesAccountNameWithHostExist (nameWithDomain: string, res: Response, sendNotFound = true) {
+  const promise = AccountModel.loadByNameWithHost(nameWithDomain)
+  return doesAccountExist(promise, res, sendNotFound)
+}
+async function doesAccountExist (p: Promise<MAccountDefault>, res: Response, sendNotFound: boolean) {
+  const account = await p
+  if (!account) {
+    if (sendNotFound === true) {
+      res.fail({
+        status: HttpStatusCode.NOT_FOUND_404,
+        message: 'Account not found'
+      })
+    }
+    return false
+  }
+  res.locals.account = account
+  return true
+}
+async function doesUserFeedTokenCorrespond (id: number, token: string, res: Response) {
+  const user = await UserModel.loadByIdWithChannels(parseInt(id + '', 10))
+  if (token !== user.feedToken) {
+    res.fail({
+      status: HttpStatusCode.FORBIDDEN_403,
+      message: 'User and token mismatch'
+    })
+    return false
+  }
+  res.locals.user = user
+  return true
+}
+// ---------------------------------------------------------------------------
+export {
+  doesAccountIdExist,
+  doesLocalAccountNameExist,
+  doesAccountNameWithHostExist,
+  doesAccountExist,
+  doesUserFeedTokenCorrespond
+}
diff --git a/server/middlewares/validators/shared/index.ts b/server/middlewares/validators/shared/index.ts
new file mode 100644
index 000000000..fa89d05f2
--- /dev/null
+++ b/server/middlewares/validators/shared/index.ts
@@ -0,0 +1,11 @@
+export * from './abuses'
+export * from './accounts'
+export * from './utils'
+export * from './video-blacklists'
+export * from './video-captions'
+export * from './video-channels'
+export * from './video-comments'
+export * from './video-imports'
+export * from './video-ownerships'
+export * from './video-playlists'
+export * from './videos'
diff --git a/server/middlewares/validators/utils.ts b/server/middlewares/validators/shared/utils.ts
index 4167f6d43..4f08560af 100644
--- a/server/middlewares/validators/utils.ts
+++ b/server/middlewares/validators/shared/utils.ts
@@ -1,15 +1,20 @@
 import * as express from 'express'
-import { query, validationResult } from 'express-validator'
+import { param, query, validationResult } from 'express-validator'
-import { logger } from '../../helpers/logger'
+import { isIdOrUUIDValid, toCompleteUUID } from '@server/helpers/custom-validators/misc'
-import { HttpStatusCode } from '../../../shared/core-utils/miscs/http-error-codes'
+import { logger } from '../../../helpers/logger'
 function areValidationErrors (req: express.Request, res: express.Response) {
  const errors = validationResult(req)
  if (!errors.isEmpty()) {
    logger.warn('Incorrect request parameters', { path: req.originalUrl, err: errors.mapped() })
-    res.status(HttpStatusCode.BAD_REQUEST_400)
+    res.fail({
-       .json({ errors: errors.mapped() })
+      message: 'Incorrect request parameters: ' + Object.keys(errors.mapped()).join(', '),
+      instance: req.originalUrl,
+      data: {
+        'invalid-params': errors.mapped()
+      }
+    })
    return true
  }
@@ -37,10 +42,24 @@ function createSortableColumns (sortableColumns: string[]) {
  return sortableColumns.concat(sortableColumnDesc)
 }
+function isValidVideoIdParam (paramName: string) {
+  return param(paramName)
+    .customSanitizer(toCompleteUUID)
+    .custom(isIdOrUUIDValid).withMessage('Should have a valid video id')
+}
+function isValidPlaylistIdParam (paramName: string) {
+  return param(paramName)
+    .customSanitizer(toCompleteUUID)
+    .custom(isIdOrUUIDValid).withMessage('Should have a valid playlist id')
+}
 // ---------------------------------------------------------------------------
 export {
  areValidationErrors,
  checkSort,
-  createSortableColumns
+  createSortableColumns,
+  isValidVideoIdParam,
+  isValidPlaylistIdParam
 }
diff --git a/server/middlewares/validators/shared/video-blacklists.ts b/server/middlewares/validators/shared/video-blacklists.ts
new file mode 100644
index 000000000..01491c10f
--- /dev/null
+++ b/server/middlewares/validators/shared/video-blacklists.ts
@@ -0,0 +1,24 @@
+import { Response } from 'express'
+import { VideoBlacklistModel } from '@server/models/video/video-blacklist'
+import { HttpStatusCode } from '@shared/core-utils'
+async function doesVideoBlacklistExist (videoId: number, res: Response) {
+  const videoBlacklist = await VideoBlacklistModel.loadByVideoId(videoId)
+  if (videoBlacklist === null) {
+    res.fail({
+      status: HttpStatusCode.NOT_FOUND_404,
+      message: 'Blacklisted video not found'
+    })
+    return false
+  }
+  res.locals.videoBlacklist = videoBlacklist
+  return true
+}
+// ---------------------------------------------------------------------------
+export {
+  doesVideoBlacklistExist
+}
diff --git a/server/middlewares/validators/shared/video-captions.ts b/server/middlewares/validators/shared/video-captions.ts
new file mode 100644
index 000000000..80f6c5a52
--- /dev/null
+++ b/server/middlewares/validators/shared/video-captions.ts
@@ -0,0 +1,25 @@
+import { Response } from 'express'
+import { VideoCaptionModel } from '@server/models/video/video-caption'
+import { MVideoId } from '@server/types/models'
+import { HttpStatusCode } from '@shared/core-utils'
+async function doesVideoCaptionExist (video: MVideoId, language: string, res: Response) {
+  const videoCaption = await VideoCaptionModel.loadByVideoIdAndLanguage(video.id, language)
+  if (!videoCaption) {
+    res.fail({
+      status: HttpStatusCode.NOT_FOUND_404,
+      message: 'Video caption not found'
+    })
+    return false
+  }
+  res.locals.videoCaption = videoCaption
+  return true
+}
+// ---------------------------------------------------------------------------
+export {
+  doesVideoCaptionExist
+}
diff --git a/server/middlewares/validators/shared/video-channels.ts b/server/middlewares/validators/shared/video-channels.ts
new file mode 100644
index 000000000..fe2e663b7
--- /dev/null
+++ b/server/middlewares/validators/shared/video-channels.ts
@@ -0,0 +1,43 @@
+import * as express from 'express'
+import { VideoChannelModel } from '@server/models/video/video-channel'
+import { MChannelBannerAccountDefault } from '@server/types/models'
+import { HttpStatusCode } from '@shared/core-utils'
+async function doesLocalVideoChannelNameExist (name: string, res: express.Response) {
+  const videoChannel = await VideoChannelModel.loadLocalByNameAndPopulateAccount(name)
+  return processVideoChannelExist(videoChannel, res)
+}
+async function doesVideoChannelIdExist (id: number, res: express.Response) {
+  const videoChannel = await VideoChannelModel.loadAndPopulateAccount(+id)
+  return processVideoChannelExist(videoChannel, res)
+}
+async function doesVideoChannelNameWithHostExist (nameWithDomain: string, res: express.Response) {
+  const videoChannel = await VideoChannelModel.loadByNameWithHostAndPopulateAccount(nameWithDomain)
+  return processVideoChannelExist(videoChannel, res)
+}
+// ---------------------------------------------------------------------------
+export {
+  doesLocalVideoChannelNameExist,
+  doesVideoChannelIdExist,
+  doesVideoChannelNameWithHostExist
+}
+function processVideoChannelExist (videoChannel: MChannelBannerAccountDefault, res: express.Response) {
+  if (!videoChannel) {
+    res.fail({
+      status: HttpStatusCode.NOT_FOUND_404,
+      message: 'Video channel not found'
+    })
+    return false
+  }
+  res.locals.videoChannel = videoChannel
+  return true
+}
diff --git a/server/middlewares/validators/shared/video-comments.ts b/server/middlewares/validators/shared/video-comments.ts
new file mode 100644
index 000000000..83ea15c98
--- /dev/null
+++ b/server/middlewares/validators/shared/video-comments.ts
@@ -0,0 +1,73 @@
+import * as express from 'express'
+import { VideoCommentModel } from '@server/models/video/video-comment'
+import { MVideoId } from '@server/types/models'
+import { HttpStatusCode } from '@shared/core-utils'
+async function doesVideoCommentThreadExist (idArg: number | string, video: MVideoId, res: express.Response) {
+  const id = parseInt(idArg + '', 10)
+  const videoComment = await VideoCommentModel.loadById(id)
+  if (!videoComment) {
+    res.fail({
+      status: HttpStatusCode.NOT_FOUND_404,
+      message: 'Video comment thread not found'
+    })
+    return false
+  }
+  if (videoComment.videoId !== video.id) {
+    res.fail({ message: 'Video comment is not associated to this video.' })
+    return false
+  }
+  if (videoComment.inReplyToCommentId !== null) {
+    res.fail({ message: 'Video comment is not a thread.' })
+    return false
+  }
+  res.locals.videoCommentThread = videoComment
+  return true
+}
+async function doesVideoCommentExist (idArg: number | string, video: MVideoId, res: express.Response) {
+  const id = parseInt(idArg + '', 10)
+  const videoComment = await VideoCommentModel.loadByIdAndPopulateVideoAndAccountAndReply(id)
+  if (!videoComment) {
+    res.fail({
+      status: HttpStatusCode.NOT_FOUND_404,
+      message: 'Video comment thread not found'
+    })
+    return false
+  }
+  if (videoComment.videoId !== video.id) {
+    res.fail({ message: 'Video comment is not associated to this video.' })
+    return false
+  }
+  res.locals.videoCommentFull = videoComment
+  return true
+}
+async function doesCommentIdExist (idArg: number | string, res: express.Response) {
+  const id = parseInt(idArg + '', 10)
+  const videoComment = await VideoCommentModel.loadByIdAndPopulateVideoAndAccountAndReply(id)
+  if (!videoComment) {
+    res.fail({
+      status: HttpStatusCode.NOT_FOUND_404,
+      message: 'Video comment thread not found'
+    })
+    return false
+  }
+  res.locals.videoCommentFull = videoComment
+  return true
+}
+export {
+  doesVideoCommentThreadExist,
+  doesVideoCommentExist,
+  doesCommentIdExist
+}
diff --git a/server/middlewares/validators/shared/video-imports.ts b/server/middlewares/validators/shared/video-imports.ts
new file mode 100644
index 000000000..0f984bc17
--- /dev/null
+++ b/server/middlewares/validators/shared/video-imports.ts
@@ -0,0 +1,22 @@
+import * as express from 'express'
+import { VideoImportModel } from '@server/models/video/video-import'
+import { HttpStatusCode } from '@shared/core-utils'
+async function doesVideoImportExist (id: number, res: express.Response) {
+  const videoImport = await VideoImportModel.loadAndPopulateVideo(id)
+  if (!videoImport) {
+    res.fail({
+      status: HttpStatusCode.NOT_FOUND_404,
+      message: 'Video import not found'
+    })
+    return false
+  }
+  res.locals.videoImport = videoImport
+  return true
+}
+export {
+  doesVideoImportExist
+}
diff --git a/server/middlewares/validators/shared/video-ownerships.ts b/server/middlewares/validators/shared/video-ownerships.ts
new file mode 100644
index 000000000..fc27006ce
--- /dev/null
+++ b/server/middlewares/validators/shared/video-ownerships.ts
@@ -0,0 +1,24 @@
+import * as express from 'express'
+import { VideoChangeOwnershipModel } from '@server/models/video/video-change-ownership'
+import { HttpStatusCode } from '@shared/core-utils'
+async function doesChangeVideoOwnershipExist (idArg: number | string, res: express.Response) {
+  const id = parseInt(idArg + '', 10)
+  const videoChangeOwnership = await VideoChangeOwnershipModel.load(id)
+  if (!videoChangeOwnership) {
+    res.fail({
+      status: HttpStatusCode.NOT_FOUND_404,
+      message: 'Video change ownership not found'
+    })
+    return false
+  }
+  res.locals.videoChangeOwnership = videoChangeOwnership
+  return true
+}
+export {
+  doesChangeVideoOwnershipExist
+}
diff --git a/server/middlewares/validators/shared/video-playlists.ts b/server/middlewares/validators/shared/video-playlists.ts
new file mode 100644
index 000000000..d762859a8
--- /dev/null
+++ b/server/middlewares/validators/shared/video-playlists.ts
@@ -0,0 +1,39 @@
+import * as express from 'express'
+import { VideoPlaylistModel } from '@server/models/video/video-playlist'
+import { MVideoPlaylist } from '@server/types/models'
+import { HttpStatusCode } from '@shared/core-utils'
+export type VideoPlaylistFetchType = 'summary' | 'all'
+async function doesVideoPlaylistExist (id: number | string, res: express.Response, fetchType: VideoPlaylistFetchType = 'summary') {
+  if (fetchType === 'summary') {
+    const videoPlaylist = await VideoPlaylistModel.loadWithAccountAndChannelSummary(id, undefined)
+    res.locals.videoPlaylistSummary = videoPlaylist
+    return handleVideoPlaylist(videoPlaylist, res)
+  }
+  const videoPlaylist = await VideoPlaylistModel.loadWithAccountAndChannel(id, undefined)
+  res.locals.videoPlaylistFull = videoPlaylist
+  return handleVideoPlaylist(videoPlaylist, res)
+}
+// ---------------------------------------------------------------------------
+export {
+  doesVideoPlaylistExist
+}
+// ---------------------------------------------------------------------------
+function handleVideoPlaylist (videoPlaylist: MVideoPlaylist, res: express.Response) {
+  if (!videoPlaylist) {
+    res.fail({
+      status: HttpStatusCode.NOT_FOUND_404,
+      message: 'Video playlist not found'
+    })
+    return false
+  }
+  return true
+}
diff --git a/server/middlewares/validators/shared/videos.ts b/server/middlewares/validators/shared/videos.ts
new file mode 100644
index 000000000..2c66c1a3a
--- /dev/null
+++ b/server/middlewares/validators/shared/videos.ts
@@ -0,0 +1,125 @@
+import { Response } from 'express'
+import { loadVideo, VideoLoadType } from '@server/lib/model-loaders'
+import { VideoChannelModel } from '@server/models/video/video-channel'
+import { VideoFileModel } from '@server/models/video/video-file'
+import {
+  MUser,
+  MUserAccountId,
+  MVideoAccountLight,
+  MVideoFormattableDetails,
+  MVideoFullLight,
+  MVideoId,
+  MVideoImmutable,
+  MVideoThumbnail
+} from '@server/types/models'
+import { HttpStatusCode } from '@shared/core-utils'
+import { UserRight } from '@shared/models'
+async function doesVideoExist (id: number | string, res: Response, fetchType: VideoLoadType = 'all') {
+  const userId = res.locals.oauth ? res.locals.oauth.token.User.id : undefined
+  const video = await loadVideo(id, fetchType, userId)
+  if (video === null) {
+    res.fail({
+      status: HttpStatusCode.NOT_FOUND_404,
+      message: 'Video not found'
+    })
+    return false
+  }
+  switch (fetchType) {
+    case 'for-api':
+      res.locals.videoAPI = video as MVideoFormattableDetails
+      break
+    case 'all':
+      res.locals.videoAll = video as MVideoFullLight
+      break
+    case 'only-immutable-attributes':
+      res.locals.onlyImmutableVideo = video as MVideoImmutable
+      break
+    case 'id':
+      res.locals.videoId = video as MVideoId
+      break
+    case 'only-video':
+      res.locals.onlyVideo = video as MVideoThumbnail
+      break
+  }
+  return true
+}
+async function doesVideoFileOfVideoExist (id: number, videoIdOrUUID: number | string, res: Response) {
+  if (!await VideoFileModel.doesVideoExistForVideoFile(id, videoIdOrUUID)) {
+    res.fail({
+      status: HttpStatusCode.NOT_FOUND_404,
+      message: 'VideoFile matching Video not found'
+    })
+    return false
+  }
+  return true
+}
+async function doesVideoChannelOfAccountExist (channelId: number, user: MUserAccountId, res: Response) {
+  const videoChannel = await VideoChannelModel.loadAndPopulateAccount(channelId)
+  if (videoChannel === null) {
+    res.fail({ message: 'Unknown video "video channel" for this instance.' })
+    return false
+  }
+  // Don't check account id if the user can update any video
+  if (user.hasRight(UserRight.UPDATE_ANY_VIDEO) === true) {
+    res.locals.videoChannel = videoChannel
+    return true
+  }
+  if (videoChannel.Account.id !== user.Account.id) {
+    res.fail({
+      message: 'Unknown video "video channel" for this account.'
+    })
+    return false
+  }
+  res.locals.videoChannel = videoChannel
+  return true
+}
+function checkUserCanManageVideo (user: MUser, video: MVideoAccountLight, right: UserRight, res: Response, onlyOwned = true) {
+  // Retrieve the user who did the request
+  if (onlyOwned && video.isOwned() === false) {
+    res.fail({
+      status: HttpStatusCode.FORBIDDEN_403,
+      message: 'Cannot manage a video of another server.'
+    })
+    return false
+  }
+  // Check if the user can delete the video
+  // The user can delete it if he has the right
+  // Or if s/he is the video's account
+  const account = video.VideoChannel.Account
+  if (user.hasRight(right) === false && account.userId !== user.id) {
+    res.fail({
+      status: HttpStatusCode.FORBIDDEN_403,
+      message: 'Cannot manage a video of another user.'
+    })
+    return false
+  }
+  return true
+}
+// ---------------------------------------------------------------------------
+export {
+  doesVideoChannelOfAccountExist,
+  doesVideoExist,
+  doesVideoFileOfVideoExist,
+  checkUserCanManageVideo
+}
diff --git a/server/middlewares/validators/sort.ts b/server/middlewares/validators/sort.ts
index beecc155b..473010460 100644
--- a/server/middlewares/validators/sort.ts
+++ b/server/middlewares/validators/sort.ts
@@ -1,5 +1,5 @@
 import { SORTABLE_COLUMNS } from '../../initializers/constants'
-import { checkSort, createSortableColumns } from './utils'
+import { checkSort, createSortableColumns } from './shared'
 // Initialize constants here for better performances
 const SORTABLE_USERS_COLUMNS = createSortableColumns(SORTABLE_COLUMNS.USERS)
@@ -9,6 +9,7 @@ const SORTABLE_ABUSES_COLUMNS = createSortableColumns(SORTABLE_COLUMNS.ABUSES)
 const SORTABLE_VIDEOS_COLUMNS = createSortableColumns(SORTABLE_COLUMNS.VIDEOS)
 const SORTABLE_VIDEOS_SEARCH_COLUMNS = createSortableColumns(SORTABLE_COLUMNS.VIDEOS_SEARCH)
 const SORTABLE_VIDEO_CHANNELS_SEARCH_COLUMNS = createSortableColumns(SORTABLE_COLUMNS.VIDEO_CHANNELS_SEARCH)
+const SORTABLE_VIDEO_PLAYLISTS_SEARCH_COLUMNS = createSortableColumns(SORTABLE_COLUMNS.VIDEO_PLAYLISTS_SEARCH)
 const SORTABLE_VIDEO_IMPORTS_COLUMNS = createSortableColumns(SORTABLE_COLUMNS.VIDEO_IMPORTS)
 const SORTABLE_VIDEO_COMMENTS_COLUMNS = createSortableColumns(SORTABLE_COLUMNS.VIDEO_COMMENT_THREADS)
 const SORTABLE_VIDEO_COMMENT_THREADS_COLUMNS = createSortableColumns(SORTABLE_COLUMNS.VIDEO_COMMENT_THREADS)
@@ -34,6 +35,7 @@ const videosSortValidator = checkSort(SORTABLE_VIDEOS_COLUMNS)
 const videoImportsSortValidator = checkSort(SORTABLE_VIDEO_IMPORTS_COLUMNS)
 const videosSearchSortValidator = checkSort(SORTABLE_VIDEOS_SEARCH_COLUMNS)
 const videoChannelsSearchSortValidator = checkSort(SORTABLE_VIDEO_CHANNELS_SEARCH_COLUMNS)
+const videoPlaylistsSearchSortValidator = checkSort(SORTABLE_VIDEO_PLAYLISTS_SEARCH_COLUMNS)
 const videoCommentsValidator = checkSort(SORTABLE_VIDEO_COMMENTS_COLUMNS)
 const videoCommentThreadsSortValidator = checkSort(SORTABLE_VIDEO_COMMENT_THREADS_COLUMNS)
 const videoRatesSortValidator = checkSort(SORTABLE_VIDEO_RATES_COLUMNS)
@@ -75,5 +77,6 @@ export {
  userNotificationsSortValidator,
  videoPlaylistsSortValidator,
  videoRedundanciesSortValidator,
+  videoPlaylistsSearchSortValidator,
  pluginsSortValidator
 }
diff --git a/server/middlewares/validators/themes.ts b/server/middlewares/validators/themes.ts
index a726a567b..d4716257f 100644
--- a/server/middlewares/validators/themes.ts
+++ b/server/middlewares/validators/themes.ts
@@ -1,11 +1,11 @@
 import * as express from 'express'
 import { param } from 'express-validator'
-import { logger } from '../../helpers/logger'
+import { HttpStatusCode } from '../../../shared/core-utils/miscs/http-error-codes'
-import { areValidationErrors } from './utils'
+import { isSafePath } from '../../helpers/custom-validators/misc'
 import { isPluginNameValid, isPluginVersionValid } from '../../helpers/custom-validators/plugins'
+import { logger } from '../../helpers/logger'
 import { PluginManager } from '../../lib/plugins/plugin-manager'
-import { isSafePath } from '../../helpers/custom-validators/misc'
+import { areValidationErrors } from './shared'
-import { HttpStatusCode } from '../../../shared/core-utils/miscs/http-error-codes'
 const serveThemeCSSValidator = [
  param('themeName').custom(isPluginNameValid).withMessage('Should have a valid theme name'),
@@ -20,11 +20,17 @@ const serveThemeCSSValidator = [
    const theme = PluginManager.Instance.getRegisteredThemeByShortName(req.params.themeName)
    if (!theme || theme.version !== req.params.themeVersion) {
-      return res.sendStatus(HttpStatusCode.NOT_FOUND_404)
+      return res.fail({
+        status: HttpStatusCode.NOT_FOUND_404,
+        message: 'No theme named ' + req.params.themeName + ' was found with version ' + req.params.themeVersion
+      })
    }
    if (theme.css.includes(req.params.staticEndpoint) === false) {
-      return res.sendStatus(HttpStatusCode.NOT_FOUND_404)
+      return res.fail({
+        status: HttpStatusCode.NOT_FOUND_404,
+        message: 'No static endpoint was found for this theme'
+      })
    }
    res.locals.registeredPlugin = theme
diff --git a/server/middlewares/validators/user-history.ts b/server/middlewares/validators/user-history.ts
index 058bf7758..1db0d9b26 100644
--- a/server/middlewares/validators/user-history.ts
+++ b/server/middlewares/validators/user-history.ts
@@ -1,8 +1,8 @@
 import * as express from 'express'
 import { body, query } from 'express-validator'
-import { logger } from '../../helpers/logger'
-import { areValidationErrors } from './utils'
 import { exists, isDateValid } from '../../helpers/custom-validators/misc'
+import { logger } from '../../helpers/logger'
+import { areValidationErrors } from './shared'
 const userHistoryListValidator = [
  query('search')
@@ -21,7 +21,7 @@ const userHistoryListValidator = [
 const userHistoryRemoveValidator = [
  body('beforeDate')
    .optional()
-    .custom(isDateValid).withMessage('Should have a valid before date'),
+    .custom(isDateValid).withMessage('Should have a before date that conforms to ISO 8601'),
  (req: express.Request, res: express.Response, next: express.NextFunction) => {
    logger.debug('Checking userHistoryRemoveValidator parameters', { parameters: req.body })
diff --git a/server/middlewares/validators/user-notifications.ts b/server/middlewares/validators/user-notifications.ts
index 21a7be08d..2f8e7686e 100644
--- a/server/middlewares/validators/user-notifications.ts
+++ b/server/middlewares/validators/user-notifications.ts
@@ -1,9 +1,9 @@
 import * as express from 'express'
 import { body, query } from 'express-validator'
-import { logger } from '../../helpers/logger'
-import { areValidationErrors } from './utils'
-import { isUserNotificationSettingValid } from '../../helpers/custom-validators/user-notifications'
 import { isNotEmptyIntArray, toBooleanOrNull } from '../../helpers/custom-validators/misc'
+import { isUserNotificationSettingValid } from '../../helpers/custom-validators/user-notifications'
+import { logger } from '../../helpers/logger'
+import { areValidationErrors } from './shared'
 const listUserNotificationsValidator = [
  query('unread')
diff --git a/server/middlewares/validators/user-subscriptions.ts b/server/middlewares/validators/user-subscriptions.ts
index 0d0c8ccbf..ab7962923 100644
--- a/server/middlewares/validators/user-subscriptions.ts
+++ b/server/middlewares/validators/user-subscriptions.ts
@@ -1,12 +1,12 @@
 import * as express from 'express'
 import { body, param, query } from 'express-validator'
-import { logger } from '../../helpers/logger'
+import { HttpStatusCode } from '../../../shared/core-utils/miscs/http-error-codes'
-import { areValidationErrors } from './utils'
-import { ActorFollowModel } from '../../models/activitypub/actor-follow'
 import { areValidActorHandles, isValidActorHandle } from '../../helpers/custom-validators/activitypub/actor'
 import { toArray } from '../../helpers/custom-validators/misc'
+import { logger } from '../../helpers/logger'
 import { WEBSERVER } from '../../initializers/constants'
-import { HttpStatusCode } from '../../../shared/core-utils/miscs/http-error-codes'
+import { ActorFollowModel } from '../../models/actor/actor-follow'
+import { areValidationErrors } from './shared'
 const userSubscriptionListValidator = [
  query('search').optional().not().isEmpty().withMessage('Should have a valid search'),
@@ -61,11 +61,10 @@ const userSubscriptionGetValidator = [
    const subscription = await ActorFollowModel.loadByActorAndTargetNameAndHostForAPI(user.Account.Actor.id, name, host)
    if (!subscription || !subscription.ActorFollowing.VideoChannel) {
-      return res
+      return res.fail({
-        .status(HttpStatusCode.NOT_FOUND_404)
+        status: HttpStatusCode.NOT_FOUND_404,
-        .json({
+        message: `Subscription ${req.params.uri} not found.`
-          error: `Subscription ${req.params.uri} not found.`
+      })
-        })
    }
    res.locals.subscription = subscription
diff --git a/server/middlewares/validators/users.ts b/server/middlewares/validators/users.ts
index 37119e279..698d7d814 100644
--- a/server/middlewares/validators/users.ts
+++ b/server/middlewares/validators/users.ts
@@ -7,7 +7,7 @@ import { HttpStatusCode } from '../../../shared/core-utils/miscs/http-error-code
 import { UserRole } from '../../../shared/models/users'
 import { UserRegister } from '../../../shared/models/users/user-register.model'
 import { isActorPreferredUsernameValid } from '../../helpers/custom-validators/activitypub/actor'
-import { isIdOrUUIDValid, toBooleanOrNull, toIntOrNull } from '../../helpers/custom-validators/misc'
+import { toBooleanOrNull, toIntOrNull } from '../../helpers/custom-validators/misc'
 import { isThemeNameValid } from '../../helpers/custom-validators/plugins'
 import {
  isNoInstanceConfigWarningModal,
@@ -30,13 +30,12 @@ import {
 } from '../../helpers/custom-validators/users'
 import { isVideoChannelNameValid } from '../../helpers/custom-validators/video-channels'
 import { logger } from '../../helpers/logger'
-import { doesVideoExist } from '../../helpers/middlewares'
-import { isSignupAllowed, isSignupAllowedForCurrentIP } from '../../helpers/signup'
 import { isThemeRegistered } from '../../lib/plugins/theme-utils'
 import { Redis } from '../../lib/redis'
-import { UserModel } from '../../models/account/user'
+import { isSignupAllowed, isSignupAllowedForCurrentIP } from '../../lib/signup'
-import { ActorModel } from '../../models/activitypub/actor'
+import { ActorModel } from '../../models/actor/actor'
-import { areValidationErrors } from './utils'
+import { UserModel } from '../../models/user/user'
+import { areValidationErrors, doesVideoExist, isValidVideoIdParam } from './shared'
 const usersListValidator = [
  query('blocked')
@@ -73,23 +72,23 @@ const usersAddValidator = [
    const authUser = res.locals.oauth.token.User
    if (authUser.role !== UserRole.ADMINISTRATOR && req.body.role !== UserRole.USER) {
-      return res
+      return res.fail({
-        .status(HttpStatusCode.FORBIDDEN_403)
+        status: HttpStatusCode.FORBIDDEN_403,
-        .json({ error: 'You can only create users (and not administrators or moderators)' })
+        message: 'You can only create users (and not administrators or moderators)'
+      })
    }
    if (req.body.channelName) {
      if (req.body.channelName === req.body.username) {
-        return res
+        return res.fail({ message: 'Channel name cannot be the same as user username.' })
-          .status(HttpStatusCode.BAD_REQUEST_400)
-          .json({ error: 'Channel name cannot be the same as user username.' })
      }
      const existing = await ActorModel.loadLocalByName(req.body.channelName)
      if (existing) {
-        return res
+        return res.fail({
-          .status(HttpStatusCode.CONFLICT_409)
+          status: HttpStatusCode.CONFLICT_409,
-          .json({ error: `Channel with name ${req.body.channelName} already exists.` })
+          message: `Channel with name ${req.body.channelName} already exists.`
+        })
      }
    }
@@ -121,20 +120,19 @@ const usersRegisterValidator = [
    const body: UserRegister = req.body
    if (body.channel) {
      if (!body.channel.name || !body.channel.displayName) {
-        return res
+        return res.fail({ message: 'Channel is optional but if you specify it, channel.name and channel.displayName are required.' })
-          .status(HttpStatusCode.BAD_REQUEST_400)
-          .json({ error: 'Channel is optional but if you specify it, channel.name and channel.displayName are required.' })
      }
      if (body.channel.name === body.username) {
-        return res.status(HttpStatusCode.BAD_REQUEST_400)
+        return res.fail({ message: 'Channel name cannot be the same as user username.' })
-                  .json({ error: 'Channel name cannot be the same as user username.' })
      }
      const existing = await ActorModel.loadLocalByName(body.channel.name)
      if (existing) {
-        return res.status(HttpStatusCode.CONFLICT_409)
+        return res.fail({
-                  .json({ error: `Channel with name ${body.channel.name} already exists.` })
+          status: HttpStatusCode.CONFLICT_409,
+          message: `Channel with name ${body.channel.name} already exists.`
+        })
      }
    }
@@ -153,8 +151,7 @@ const usersRemoveValidator = [
    const user = res.locals.user
    if (user.username === 'root') {
-      return res.status(HttpStatusCode.BAD_REQUEST_400)
+      return res.fail({ message: 'Cannot remove the root user' })
-                .json({ error: 'Cannot remove the root user' })
    }
    return next()
@@ -173,8 +170,7 @@ const usersBlockingValidator = [
    const user = res.locals.user
    if (user.username === 'root') {
-      return res.status(HttpStatusCode.BAD_REQUEST_400)
+      return res.fail({ message: 'Cannot block the root user' })
-                .json({ error: 'Cannot block the root user' })
    }
    return next()
@@ -185,9 +181,7 @@ const deleteMeValidator = [
  (req: express.Request, res: express.Response, next: express.NextFunction) => {
    const user = res.locals.oauth.token.User
    if (user.username === 'root') {
-      return res.status(HttpStatusCode.BAD_REQUEST_400)
+      return res.fail({ message: 'You cannot delete your root account.' })
-                .json({ error: 'You cannot delete your root account.' })
-                .end()
    }
    return next()
@@ -217,8 +211,7 @@ const usersUpdateValidator = [
    const user = res.locals.user
    if (user.username === 'root' && req.body.role !== undefined && user.role !== req.body.role) {
-      return res.status(HttpStatusCode.BAD_REQUEST_400)
+      return res.fail({ message: 'Cannot change root role.' })
-                .json({ error: 'Cannot change root role.' })
    }
    return next()
@@ -273,18 +266,18 @@ const usersUpdateMeValidator = [
    if (req.body.password || req.body.email) {
      if (user.pluginAuth !== null) {
-        return res.status(HttpStatusCode.BAD_REQUEST_400)
+        return res.fail({ message: 'You cannot update your email or password that is associated with an external auth system.' })
-                  .json({ error: 'You cannot update your email or password that is associated with an external auth system.' })
      }
      if (!req.body.currentPassword) {
-        return res.status(HttpStatusCode.BAD_REQUEST_400)
+        return res.fail({ message: 'currentPassword parameter is missing.' })
-                  .json({ error: 'currentPassword parameter is missing.' })
      }
      if (await user.isPasswordMatch(req.body.currentPassword) !== true) {
-        return res.status(HttpStatusCode.UNAUTHORIZED_401)
+        return res.fail({
-                  .json({ error: 'currentPassword is invalid.' })
+          status: HttpStatusCode.UNAUTHORIZED_401,
+          message: 'currentPassword is invalid.'
+        })
      }
    }
@@ -309,7 +302,7 @@ const usersGetValidator = [
 ]
 const usersVideoRatingValidator = [
-  param('videoId').custom(isIdOrUUIDValid).not().isEmpty().withMessage('Should have a valid video id'),
+  isValidVideoIdParam('videoId'),
  async (req: express.Request, res: express.Response, next: express.NextFunction) => {
    logger.debug('Checking usersVideoRating parameters', { parameters: req.params })
@@ -335,8 +328,10 @@ const ensureUserRegistrationAllowed = [
    )
    if (allowedResult.allowed === false) {
-      return res.status(HttpStatusCode.FORBIDDEN_403)
+      return res.fail({
-                .json({ error: allowedResult.errorMessage || 'User registration is not enabled or user limit is reached.' })
+        status: HttpStatusCode.FORBIDDEN_403,
+        message: allowedResult.errorMessage || 'User registration is not enabled or user limit is reached.'
+      })
    }
    return next()
@@ -348,8 +343,10 @@ const ensureUserRegistrationAllowedForIP = [
    const allowed = isSignupAllowedForCurrentIP(req.ip)
    if (allowed === false) {
-      return res.status(HttpStatusCode.FORBIDDEN_403)
+      return res.fail({
-                .json({ error: 'You are not on a network authorized for registration.' })
+        status: HttpStatusCode.FORBIDDEN_403,
+        message: 'You are not on a network authorized for registration.'
+      })
    }
    return next()
@@ -390,9 +387,10 @@ const usersResetPasswordValidator = [
    const redisVerificationString = await Redis.Instance.getResetPasswordLink(user.id)
    if (redisVerificationString !== req.body.verificationString) {
-      return res
+      return res.fail({
-        .status(HttpStatusCode.FORBIDDEN_403)
+        status: HttpStatusCode.FORBIDDEN_403,
-        .json({ error: 'Invalid verification string.' })
+        message: 'Invalid verification string.'
+      })
    }
    return next()
@@ -437,9 +435,10 @@ const usersVerifyEmailValidator = [
    const redisVerificationString = await Redis.Instance.getVerifyEmailLink(user.id)
    if (redisVerificationString !== req.body.verificationString) {
-      return res
+      return res.fail({
-        .status(HttpStatusCode.FORBIDDEN_403)
+        status: HttpStatusCode.FORBIDDEN_403,
-        .json({ error: 'Invalid verification string.' })
+        message: 'Invalid verification string.'
+      })
    }
    return next()
@@ -455,8 +454,10 @@ const ensureAuthUserOwnsAccountValidator = [
    const user = res.locals.oauth.token.User
    if (res.locals.account.id !== user.Account.id) {
-      return res.status(HttpStatusCode.FORBIDDEN_403)
+      return res.fail({
-                .json({ error: 'Only owner can access ratings list.' })
+        status: HttpStatusCode.FORBIDDEN_403,
+        message: 'Only owner can access ratings list.'
+      })
    }
    return next()
@@ -471,8 +472,10 @@ const ensureCanManageUser = [
    if (authUser.role === UserRole.ADMINISTRATOR) return next()
    if (authUser.role === UserRole.MODERATOR && onUser.role === UserRole.USER) return next()
-    return res.status(HttpStatusCode.FORBIDDEN_403)
+    return res.fail({
-      .json({ error: 'A moderator can only manager users.' })
+      status: HttpStatusCode.FORBIDDEN_403,
+      message: 'A moderator can only manager users.'
+    })
  }
 ]
@@ -515,15 +518,19 @@ async function checkUserNameOrEmailDoesNotAlreadyExist (username: string, email:
  const user = await UserModel.loadByUsernameOrEmail(username, email)
  if (user) {
-    res.status(HttpStatusCode.CONFLICT_409)
+    res.fail({
-              .json({ error: 'User with this username or email already exists.' })
+      status: HttpStatusCode.CONFLICT_409,
+      message: 'User with this username or email already exists.'
+    })
    return false
  }
  const actor = await ActorModel.loadLocalByName(username)
  if (actor) {
-    res.status(HttpStatusCode.CONFLICT_409)
+    res.fail({
-       .json({ error: 'Another actor (account/channel) with this name on this instance already exists or has already existed.' })
+      status: HttpStatusCode.CONFLICT_409,
+      message: 'Another actor (account/channel) with this name on this instance already exists or has already existed.'
+    })
    return false
  }
@@ -535,14 +542,15 @@ async function checkUserExist (finder: () => Promise<MUserDefault>, res: express
  if (!user) {
    if (abortResponse === true) {
-      res.status(HttpStatusCode.NOT_FOUND_404)
+      res.fail({
-        .json({ error: 'User not found' })
+        status: HttpStatusCode.NOT_FOUND_404,
+        message: 'User not found'
+      })
    }
    return false
  }
  res.locals.user = user
  return true
 }
diff --git a/server/middlewares/validators/videos/index.ts b/server/middlewares/validators/videos/index.ts
index 1eabada0a..369c2c9b6 100644
--- a/server/middlewares/validators/videos/index.ts
+++ b/server/middlewares/validators/videos/index.ts
@@ -3,6 +3,8 @@ export * from './video-captions'
 export * from './video-channels'
 export * from './video-comments'
 export * from './video-imports'
+export * from './video-live'
+export * from './video-ownership-changes'
 export * from './video-watch'
 export * from './video-rates'
 export * from './video-shares'
diff --git a/server/middlewares/validators/videos/video-blacklist.ts b/server/middlewares/validators/videos/video-blacklist.ts
index 88c788a43..21141d84d 100644
--- a/server/middlewares/validators/videos/video-blacklist.ts
+++ b/server/middlewares/validators/videos/video-blacklist.ts
@@ -1,14 +1,13 @@
 import * as express from 'express'
-import { body, param, query } from 'express-validator'
+import { body, query } from 'express-validator'
-import { isBooleanValid, isIdOrUUIDValid, toBooleanOrNull, toIntOrNull } from '../../../helpers/custom-validators/misc'
+import { HttpStatusCode } from '../../../../shared/core-utils/miscs/http-error-codes'
+import { isBooleanValid, toBooleanOrNull, toIntOrNull } from '../../../helpers/custom-validators/misc'
 import { isVideoBlacklistReasonValid, isVideoBlacklistTypeValid } from '../../../helpers/custom-validators/video-blacklist'
 import { logger } from '../../../helpers/logger'
-import { doesVideoBlacklistExist, doesVideoExist } from '../../../helpers/middlewares'
+import { areValidationErrors, doesVideoBlacklistExist, doesVideoExist, isValidVideoIdParam } from '../shared'
-import { areValidationErrors } from '../utils'
-import { HttpStatusCode } from '../../../../shared/core-utils/miscs/http-error-codes'
 const videosBlacklistRemoveValidator = [
-  param('videoId').custom(isIdOrUUIDValid).not().isEmpty().withMessage('Should have a valid videoId'),
+  isValidVideoIdParam('videoId'),
  async (req: express.Request, res: express.Response, next: express.NextFunction) => {
    logger.debug('Checking blacklistRemove parameters.', { parameters: req.params })
@@ -22,7 +21,8 @@ const videosBlacklistRemoveValidator = [
 ]
 const videosBlacklistAddValidator = [
-  param('videoId').custom(isIdOrUUIDValid).not().isEmpty().withMessage('Should have a valid videoId'),
+  isValidVideoIdParam('videoId'),
  body('unfederate')
    .optional()
    .customSanitizer(toBooleanOrNull)
@@ -39,10 +39,10 @@ const videosBlacklistAddValidator = [
    const video = res.locals.videoAll
    if (req.body.unfederate === true && video.remote === true) {
-      return res
+      return res.fail({
-        .status(HttpStatusCode.CONFLICT_409)
+        status: HttpStatusCode.CONFLICT_409,
-        .send({ error: 'You cannot unfederate a remote video.' })
+        message: 'You cannot unfederate a remote video.'
-        .end()
+      })
    }
    return next()
@@ -50,7 +50,8 @@ const videosBlacklistAddValidator = [
 ]
 const videosBlacklistUpdateValidator = [
-  param('videoId').custom(isIdOrUUIDValid).not().isEmpty().withMessage('Should have a valid videoId'),
+  isValidVideoIdParam('videoId'),
  body('reason')
    .optional()
    .custom(isVideoBlacklistReasonValid).withMessage('Should have a valid reason'),
diff --git a/server/middlewares/validators/videos/video-captions.ts b/server/middlewares/validators/videos/video-captions.ts
index 872d9c2ab..2946f3e15 100644
--- a/server/middlewares/validators/videos/video-captions.ts
+++ b/server/middlewares/validators/videos/video-captions.ts
@@ -1,17 +1,18 @@
 import * as express from 'express'
-import { areValidationErrors } from '../utils'
-import { isIdOrUUIDValid } from '../../../helpers/custom-validators/misc'
 import { body, param } from 'express-validator'
-import { CONSTRAINTS_FIELDS, MIMETYPES } from '../../../initializers/constants'
 import { UserRight } from '../../../../shared'
-import { logger } from '../../../helpers/logger'
 import { isVideoCaptionFile, isVideoCaptionLanguageValid } from '../../../helpers/custom-validators/video-captions'
 import { cleanUpReqFiles } from '../../../helpers/express-utils'
-import { checkUserCanManageVideo, doesVideoCaptionExist, doesVideoExist } from '../../../helpers/middlewares'
+import { logger } from '../../../helpers/logger'
+import { CONSTRAINTS_FIELDS, MIMETYPES } from '../../../initializers/constants'
+import { areValidationErrors, checkUserCanManageVideo, doesVideoCaptionExist, doesVideoExist, isValidVideoIdParam } from '../shared'
 const addVideoCaptionValidator = [
-  param('videoId').custom(isIdOrUUIDValid).not().isEmpty().withMessage('Should have a valid video id'),
+  isValidVideoIdParam('videoId'),
-  param('captionLanguage').custom(isVideoCaptionLanguageValid).not().isEmpty().withMessage('Should have a valid caption language'),
+  param('captionLanguage')
+    .custom(isVideoCaptionLanguageValid).not().isEmpty().withMessage('Should have a valid caption language'),
  body('captionfile')
    .custom((_, { req }) => isVideoCaptionFile(req.files, 'captionfile'))
    .withMessage(
@@ -35,8 +36,10 @@ const addVideoCaptionValidator = [
 ]
 const deleteVideoCaptionValidator = [
-  param('videoId').custom(isIdOrUUIDValid).not().isEmpty().withMessage('Should have a valid video id'),
+  isValidVideoIdParam('videoId'),
-  param('captionLanguage').custom(isVideoCaptionLanguageValid).not().isEmpty().withMessage('Should have a valid caption language'),
+  param('captionLanguage')
+    .custom(isVideoCaptionLanguageValid).not().isEmpty().withMessage('Should have a valid caption language'),
  async (req: express.Request, res: express.Response, next: express.NextFunction) => {
    logger.debug('Checking deleteVideoCaption parameters', { parameters: req.params })
@@ -54,7 +57,7 @@ const deleteVideoCaptionValidator = [
 ]
 const listVideoCaptionsValidator = [
-  param('videoId').custom(isIdOrUUIDValid).not().isEmpty().withMessage('Should have a valid video id'),
+  isValidVideoIdParam('videoId'),
  async (req: express.Request, res: express.Response, next: express.NextFunction) => {
    logger.debug('Checking listVideoCaptions parameters', { parameters: req.params })
diff --git a/server/middlewares/validators/videos/video-channels.ts b/server/middlewares/validators/videos/video-channels.ts
index 2463d281c..e7df185e4 100644
--- a/server/middlewares/validators/videos/video-channels.ts
+++ b/server/middlewares/validators/videos/video-channels.ts
@@ -3,6 +3,7 @@ import { body, param, query } from 'express-validator'
 import { VIDEO_CHANNELS } from '@server/initializers/constants'
 import { MChannelAccountDefault, MUser } from '@server/types/models'
 import { UserRight } from '../../../../shared'
+import { HttpStatusCode } from '../../../../shared/core-utils/miscs/http-error-codes'
 import { isActorPreferredUsernameValid } from '../../../helpers/custom-validators/activitypub/actor'
 import { isBooleanValid, toBooleanOrNull } from '../../../helpers/custom-validators/misc'
 import {
@@ -11,11 +12,9 @@ import {
  isVideoChannelSupportValid
 } from '../../../helpers/custom-validators/video-channels'
 import { logger } from '../../../helpers/logger'
-import { doesLocalVideoChannelNameExist, doesVideoChannelNameWithHostExist } from '../../../helpers/middlewares'
+import { ActorModel } from '../../../models/actor/actor'
-import { ActorModel } from '../../../models/activitypub/actor'
 import { VideoChannelModel } from '../../../models/video/video-channel'
-import { areValidationErrors } from '../utils'
+import { areValidationErrors, doesLocalVideoChannelNameExist, doesVideoChannelNameWithHostExist } from '../shared'
-import { HttpStatusCode } from '../../../../shared/core-utils/miscs/http-error-codes'
 const videoChannelsAddValidator = [
  body('name').custom(isActorPreferredUsernameValid).withMessage('Should have a valid channel name'),
@@ -30,17 +29,16 @@ const videoChannelsAddValidator = [
    const actor = await ActorModel.loadLocalByName(req.body.name)
    if (actor) {
-      res.status(HttpStatusCode.CONFLICT_409)
+      res.fail({
-         .send({ error: 'Another actor (account/channel) with this name on this instance already exists or has already existed.' })
+        status: HttpStatusCode.CONFLICT_409,
-         .end()
+        message: 'Another actor (account/channel) with this name on this instance already exists or has already existed.'
+      })
      return false
    }
    const count = await VideoChannelModel.countByAccount(res.locals.oauth.token.User.Account.id)
    if (count >= VIDEO_CHANNELS.MAX_PER_USER) {
-      res.status(HttpStatusCode.BAD_REQUEST_400)
+      res.fail({ message: `You cannot create more than ${VIDEO_CHANNELS.MAX_PER_USER} channels` })
-        .send({ error: `You cannot create more than ${VIDEO_CHANNELS.MAX_PER_USER} channels` })
-        .end()
      return false
    }
@@ -71,13 +69,17 @@ const videoChannelsUpdateValidator = [
    // We need to make additional checks
    if (res.locals.videoChannel.Actor.isOwned() === false) {
-      return res.status(HttpStatusCode.FORBIDDEN_403)
+      return res.fail({
-        .json({ error: 'Cannot update video channel of another server' })
+        status: HttpStatusCode.FORBIDDEN_403,
+        message: 'Cannot update video channel of another server'
+      })
    }
    if (res.locals.videoChannel.Account.userId !== res.locals.oauth.token.User.id) {
-      return res.status(HttpStatusCode.FORBIDDEN_403)
+      return res.fail({
-        .json({ error: 'Cannot update video channel of another user' })
+        status: HttpStatusCode.FORBIDDEN_403,
+        message: 'Cannot update video channel of another user'
+      })
    }
    return next()
@@ -139,6 +141,18 @@ const videoChannelStatsValidator = [
  }
 ]
+const videoChannelsListValidator = [
+  query('search').optional().not().isEmpty().withMessage('Should have a valid search'),
+  (req: express.Request, res: express.Response, next: express.NextFunction) => {
+    logger.debug('Checking video channels search query', { parameters: req.query })
+    if (areValidationErrors(req, res)) return
+    return next()
+  }
+]
 // ---------------------------------------------------------------------------
 export {
@@ -146,6 +160,7 @@ export {
  videoChannelsUpdateValidator,
  videoChannelsRemoveValidator,
  videoChannelsNameWithHostValidator,
+  videoChannelsListValidator,
  localVideoChannelValidator,
  videoChannelStatsValidator
 }
@@ -154,10 +169,10 @@ export {
 function checkUserCanDeleteVideoChannel (user: MUser, videoChannel: MChannelAccountDefault, res: express.Response) {
  if (videoChannel.Actor.isOwned() === false) {
-    res.status(HttpStatusCode.FORBIDDEN_403)
+    res.fail({
-              .json({ error: 'Cannot remove video channel of another server.' })
+      status: HttpStatusCode.FORBIDDEN_403,
-              .end()
+      message: 'Cannot remove video channel of another server.'
+    })
    return false
  }
@@ -165,10 +180,10 @@ function checkUserCanDeleteVideoChannel (user: MUser, videoChannel: MChannelAcco
  // The user can delete it if s/he is an admin
  // Or if s/he is the video channel's account
  if (user.hasRight(UserRight.REMOVE_ANY_VIDEO_CHANNEL) === false && videoChannel.Account.userId !== user.id) {
-    res.status(HttpStatusCode.FORBIDDEN_403)
+    res.fail({
-              .json({ error: 'Cannot remove video channel of another user' })
+      status: HttpStatusCode.FORBIDDEN_403,
-              .end()
+      message: 'Cannot remove video channel of another user'
+    })
    return false
  }
@@ -179,10 +194,10 @@ async function checkVideoChannelIsNotTheLastOne (res: express.Response) {
  const count = await VideoChannelModel.countByAccount(res.locals.oauth.token.User.Account.id)
  if (count <= 1) {
-    res.status(HttpStatusCode.CONFLICT_409)
+    res.fail({
-       .json({ error: 'Cannot remove the last channel of this user' })
+      status: HttpStatusCode.CONFLICT_409,
-       .end()
+      message: 'Cannot remove the last channel of this user'
+    })
    return false
  }
diff --git a/server/middlewares/validators/videos/video-comments.ts b/server/middlewares/validators/videos/video-comments.ts
index 1afacfed8..885506ebe 100644
--- a/server/middlewares/validators/videos/video-comments.ts
+++ b/server/middlewares/validators/videos/video-comments.ts
@@ -2,19 +2,14 @@ import * as express from 'express'
 import { body, param, query } from 'express-validator'
 import { MUserAccountUrl } from '@server/types/models'
 import { UserRight } from '../../../../shared'
-import { exists, isBooleanValid, isIdOrUUIDValid, isIdValid, toBooleanOrNull } from '../../../helpers/custom-validators/misc'
+import { HttpStatusCode } from '../../../../shared/core-utils/miscs/http-error-codes'
-import {
+import { exists, isBooleanValid, isIdValid, toBooleanOrNull } from '../../../helpers/custom-validators/misc'
-  doesVideoCommentExist,
+import { isValidVideoCommentText } from '../../../helpers/custom-validators/video-comments'
-  doesVideoCommentThreadExist,
-  isValidVideoCommentText
-} from '../../../helpers/custom-validators/video-comments'
 import { logger } from '../../../helpers/logger'
-import { doesVideoExist } from '../../../helpers/middlewares'
 import { AcceptResult, isLocalVideoCommentReplyAccepted, isLocalVideoThreadAccepted } from '../../../lib/moderation'
 import { Hooks } from '../../../lib/plugins/hooks'
 import { MCommentOwnerVideoReply, MVideo, MVideoFullLight } from '../../../types/models/video'
-import { areValidationErrors } from '../utils'
+import { areValidationErrors, doesVideoCommentExist, doesVideoCommentThreadExist, doesVideoExist, isValidVideoIdParam } from '../shared'
-import { HttpStatusCode } from '../../../../shared/core-utils/miscs/http-error-codes'
 const listVideoCommentsValidator = [
  query('isLocal')
@@ -45,7 +40,7 @@ const listVideoCommentsValidator = [
 ]
 const listVideoCommentThreadsValidator = [
-  param('videoId').custom(isIdOrUUIDValid).not().isEmpty().withMessage('Should have a valid videoId'),
+  isValidVideoIdParam('videoId'),
  async (req: express.Request, res: express.Response, next: express.NextFunction) => {
    logger.debug('Checking listVideoCommentThreads parameters.', { parameters: req.params })
@@ -58,8 +53,10 @@ const listVideoCommentThreadsValidator = [
 ]
 const listVideoThreadCommentsValidator = [
-  param('videoId').custom(isIdOrUUIDValid).not().isEmpty().withMessage('Should have a valid videoId'),
+  isValidVideoIdParam('videoId'),
-  param('threadId').custom(isIdValid).not().isEmpty().withMessage('Should have a valid threadId'),
+  param('threadId')
+    .custom(isIdValid).not().isEmpty().withMessage('Should have a valid threadId'),
  async (req: express.Request, res: express.Response, next: express.NextFunction) => {
    logger.debug('Checking listVideoThreadComments parameters.', { parameters: req.params })
@@ -73,8 +70,10 @@ const listVideoThreadCommentsValidator = [
 ]
 const addVideoCommentThreadValidator = [
-  param('videoId').custom(isIdOrUUIDValid).not().isEmpty().withMessage('Should have a valid videoId'),
+  isValidVideoIdParam('videoId'),
-  body('text').custom(isValidVideoCommentText).not().isEmpty().withMessage('Should have a valid comment text'),
+  body('text')
+    .custom(isValidVideoCommentText).not().isEmpty().withMessage('Should have a valid comment text'),
  async (req: express.Request, res: express.Response, next: express.NextFunction) => {
    logger.debug('Checking addVideoCommentThread parameters.', { parameters: req.params, body: req.body })
@@ -89,8 +88,10 @@ const addVideoCommentThreadValidator = [
 ]
 const addVideoCommentReplyValidator = [
-  param('videoId').custom(isIdOrUUIDValid).not().isEmpty().withMessage('Should have a valid videoId'),
+  isValidVideoIdParam('videoId'),
  param('commentId').custom(isIdValid).not().isEmpty().withMessage('Should have a valid commentId'),
  body('text').custom(isValidVideoCommentText).not().isEmpty().withMessage('Should have a valid comment text'),
  async (req: express.Request, res: express.Response, next: express.NextFunction) => {
@@ -107,8 +108,10 @@ const addVideoCommentReplyValidator = [
 ]
 const videoCommentGetValidator = [
-  param('videoId').custom(isIdOrUUIDValid).not().isEmpty().withMessage('Should have a valid videoId'),
+  isValidVideoIdParam('videoId'),
-  param('commentId').custom(isIdValid).not().isEmpty().withMessage('Should have a valid commentId'),
+  param('commentId')
+    .custom(isIdValid).not().isEmpty().withMessage('Should have a valid commentId'),
  async (req: express.Request, res: express.Response, next: express.NextFunction) => {
    logger.debug('Checking videoCommentGetValidator parameters.', { parameters: req.params })
@@ -122,7 +125,8 @@ const videoCommentGetValidator = [
 ]
 const removeVideoCommentValidator = [
-  param('videoId').custom(isIdOrUUIDValid).not().isEmpty().withMessage('Should have a valid videoId'),
+  isValidVideoIdParam('videoId'),
  param('commentId').custom(isIdValid).not().isEmpty().withMessage('Should have a valid commentId'),
  async (req: express.Request, res: express.Response, next: express.NextFunction) => {
@@ -155,9 +159,10 @@ export {
 function isVideoCommentsEnabled (video: MVideo, res: express.Response) {
  if (video.commentsEnabled !== true) {
-    res.status(HttpStatusCode.CONFLICT_409)
+    res.fail({
-       .json({ error: 'Video comments are disabled for this video.' })
+      status: HttpStatusCode.CONFLICT_409,
+      message: 'Video comments are disabled for this video.'
+    })
    return false
  }
@@ -166,9 +171,10 @@ function isVideoCommentsEnabled (video: MVideo, res: express.Response) {
 function checkUserCanDeleteVideoComment (user: MUserAccountUrl, videoComment: MCommentOwnerVideoReply, res: express.Response) {
  if (videoComment.isDeleted()) {
-    res.status(HttpStatusCode.CONFLICT_409)
+    res.fail({
-       .json({ error: 'This comment is already deleted' })
+      status: HttpStatusCode.CONFLICT_409,
+      message: 'This comment is already deleted'
+    })
    return false
  }
@@ -179,9 +185,10 @@ function checkUserCanDeleteVideoComment (user: MUserAccountUrl, videoComment: MC
    videoComment.accountId !== userAccount.id && // Not the comment owner
    videoComment.Video.VideoChannel.accountId !== userAccount.id // Not the video owner
  ) {
-    res.status(HttpStatusCode.FORBIDDEN_403)
+    res.fail({
-      .json({ error: 'Cannot remove video comment of another user' })
+      status: HttpStatusCode.FORBIDDEN_403,
+      message: 'Cannot remove video comment of another user'
+    })
    return false
  }
@@ -215,9 +222,11 @@ async function isVideoCommentAccepted (req: express.Request, res: express.Respon
  if (!acceptedResult || acceptedResult.accepted !== true) {
    logger.info('Refused local comment.', { acceptedResult, acceptParameters })
-    res.status(HttpStatusCode.FORBIDDEN_403)
-       .json({ error: acceptedResult?.errorMessage || 'Refused local comment' })
+    res.fail({
+      status: HttpStatusCode.FORBIDDEN_403,
+      message: acceptedResult?.errorMessage || 'Refused local comment'
+    })
    return false
  }
diff --git a/server/middlewares/validators/videos/video-imports.ts b/server/middlewares/validators/videos/video-imports.ts
index c53af3861..85dc647ce 100644
--- a/server/middlewares/validators/videos/video-imports.ts
+++ b/server/middlewares/validators/videos/video-imports.ts
@@ -2,18 +2,17 @@ import * as express from 'express'
 import { body } from 'express-validator'
 import { isPreImportVideoAccepted } from '@server/lib/moderation'
 import { Hooks } from '@server/lib/plugins/hooks'
+import { HttpStatusCode } from '@shared/core-utils/miscs/http-error-codes'
 import { VideoImportCreate } from '@shared/models/videos/import/video-import-create.model'
 import { isIdValid, toIntOrNull } from '../../../helpers/custom-validators/misc'
 import { isVideoImportTargetUrlValid, isVideoImportTorrentFile } from '../../../helpers/custom-validators/video-imports'
 import { isVideoMagnetUriValid, isVideoNameValid } from '../../../helpers/custom-validators/videos'
 import { cleanUpReqFiles } from '../../../helpers/express-utils'
 import { logger } from '../../../helpers/logger'
-import { doesVideoChannelOfAccountExist } from '../../../helpers/middlewares'
 import { CONFIG } from '../../../initializers/config'
 import { CONSTRAINTS_FIELDS } from '../../../initializers/constants'
-import { areValidationErrors } from '../utils'
+import { areValidationErrors, doesVideoChannelOfAccountExist } from '../shared'
 import { getCommonVideoEditAttributes } from './videos'
-import { HttpStatusCode } from '@shared/core-utils/miscs/http-error-codes'
 const videoImportAddValidator = getCommonVideoEditAttributes().concat([
  body('channelId')
@@ -33,7 +32,9 @@ const videoImportAddValidator = getCommonVideoEditAttributes().concat([
    ),
  body('name')
    .optional()
-    .custom(isVideoNameValid).withMessage('Should have a valid name'),
+    .custom(isVideoNameValid).withMessage(
+      `Should have a video name between ${CONSTRAINTS_FIELDS.VIDEOS.NAME.min} and ${CONSTRAINTS_FIELDS.VIDEOS.NAME.max} characters long`
+    ),
  async (req: express.Request, res: express.Response, next: express.NextFunction) => {
    logger.debug('Checking videoImportAddValidator parameters', { parameters: req.body })
@@ -45,16 +46,20 @@ const videoImportAddValidator = getCommonVideoEditAttributes().concat([
    if (CONFIG.IMPORT.VIDEOS.HTTP.ENABLED !== true && req.body.targetUrl) {
      cleanUpReqFiles(req)
-      return res.status(HttpStatusCode.CONFLICT_409)
-        .json({ error: 'HTTP import is not enabled on this instance.' })
+      return res.fail({
-        .end()
+        status: HttpStatusCode.CONFLICT_409,
+        message: 'HTTP import is not enabled on this instance.'
+      })
    }
    if (CONFIG.IMPORT.VIDEOS.TORRENT.ENABLED !== true && (req.body.magnetUri || torrentFile)) {
      cleanUpReqFiles(req)
-      return res.status(HttpStatusCode.CONFLICT_409)
-                .json({ error: 'Torrent/magnet URI import is not enabled on this instance.' })
+      return res.fail({
-                .end()
+        status: HttpStatusCode.CONFLICT_409,
+        message: 'Torrent/magnet URI import is not enabled on this instance.'
+      })
    }
    if (!await doesVideoChannelOfAccountExist(req.body.channelId, user, res)) return cleanUpReqFiles(req)
@@ -63,9 +68,7 @@ const videoImportAddValidator = getCommonVideoEditAttributes().concat([
    if (!req.body.targetUrl && !req.body.magnetUri && !torrentFile) {
      cleanUpReqFiles(req)
-      return res.status(HttpStatusCode.BAD_REQUEST_400)
+      return res.fail({ message: 'Should have a magnetUri or a targetUrl or a torrent file.' })
-        .json({ error: 'Should have a magnetUri or a targetUrl or a torrent file.' })
-        .end()
    }
    if (!await isImportAccepted(req, res)) return cleanUpReqFiles(req)
@@ -101,9 +104,11 @@ async function isImportAccepted (req: express.Request, res: express.Response) {
  if (!acceptedResult || acceptedResult.accepted !== true) {
    logger.info('Refused to import video.', { acceptedResult, acceptParameters })
-    res.status(HttpStatusCode.FORBIDDEN_403)
-       .json({ error: acceptedResult.errorMessage || 'Refused to import video' })
+    res.fail({
+      status: HttpStatusCode.FORBIDDEN_403,
+      message: acceptedResult.errorMessage || 'Refused to import video'
+    })
    return false
  }
diff --git a/server/middlewares/validators/videos/video-live.ts b/server/middlewares/validators/videos/video-live.ts
index 3a73e1272..7cfb935e3 100644
--- a/server/middlewares/validators/videos/video-live.ts
+++ b/server/middlewares/validators/videos/video-live.ts
@@ -1,22 +1,28 @@
 import * as express from 'express'
-import { body, param } from 'express-validator'
+import { body } from 'express-validator'
-import { checkUserCanManageVideo, doesVideoChannelOfAccountExist, doesVideoExist } from '@server/helpers/middlewares/videos'
+import { CONSTRAINTS_FIELDS } from '@server/initializers/constants'
+import { isLocalLiveVideoAccepted } from '@server/lib/moderation'
+import { Hooks } from '@server/lib/plugins/hooks'
+import { VideoModel } from '@server/models/video/video'
 import { VideoLiveModel } from '@server/models/video/video-live'
+import { HttpStatusCode } from '@shared/core-utils/miscs/http-error-codes'
 import { ServerErrorCode, UserRight, VideoState } from '@shared/models'
-import { isBooleanValid, isIdOrUUIDValid, isIdValid, toBooleanOrNull, toIntOrNull } from '../../../helpers/custom-validators/misc'
+import { isBooleanValid, isIdValid, toBooleanOrNull, toIntOrNull } from '../../../helpers/custom-validators/misc'
 import { isVideoNameValid } from '../../../helpers/custom-validators/videos'
 import { cleanUpReqFiles } from '../../../helpers/express-utils'
 import { logger } from '../../../helpers/logger'
 import { CONFIG } from '../../../initializers/config'
-import { areValidationErrors } from '../utils'
+import {
+  areValidationErrors,
+  checkUserCanManageVideo,
+  doesVideoChannelOfAccountExist,
+  doesVideoExist,
+  isValidVideoIdParam
+} from '../shared'
 import { getCommonVideoEditAttributes } from './videos'
-import { VideoModel } from '@server/models/video/video'
-import { Hooks } from '@server/lib/plugins/hooks'
-import { isLocalLiveVideoAccepted } from '@server/lib/moderation'
-import { HttpStatusCode } from '@shared/core-utils/miscs/http-error-codes'
 const videoLiveGetValidator = [
-  param('videoId').custom(isIdOrUUIDValid).not().isEmpty().withMessage('Should have a valid videoId'),
+  isValidVideoIdParam('videoId'),
  async (req: express.Request, res: express.Response, next: express.NextFunction) => {
    logger.debug('Checking videoLiveGetValidator parameters', { parameters: req.params, user: res.locals.oauth.token.User.username })
@@ -29,7 +35,12 @@ const videoLiveGetValidator = [
    if (!checkUserCanManageVideo(user, res.locals.videoAll, UserRight.GET_ANY_LIVE, res, false)) return
    const videoLive = await VideoLiveModel.loadByVideoId(res.locals.videoAll.id)
-    if (!videoLive) return res.sendStatus(HttpStatusCode.NOT_FOUND_404)
+    if (!videoLive) {
+      return res.fail({
+        status: HttpStatusCode.NOT_FOUND_404,
+        message: 'Live video not found'
+      })
+    }
    res.locals.videoLive = videoLive
@@ -43,7 +54,9 @@ const videoLiveAddValidator = getCommonVideoEditAttributes().concat([
    .custom(isIdValid).withMessage('Should have correct video channel id'),
  body('name')
-    .custom(isVideoNameValid).withMessage('Should have a valid name'),
+    .custom(isVideoNameValid).withMessage(
+      `Should have a video name between ${CONSTRAINTS_FIELDS.VIDEOS.NAME.min} and ${CONSTRAINTS_FIELDS.VIDEOS.NAME.max} characters long`
+    ),
  body('saveReplay')
    .optional()
@@ -63,22 +76,27 @@ const videoLiveAddValidator = getCommonVideoEditAttributes().concat([
    if (CONFIG.LIVE.ENABLED !== true) {
      cleanUpReqFiles(req)
-      return res.status(HttpStatusCode.FORBIDDEN_403)
+      return res.fail({
-        .json({ error: 'Live is not enabled on this instance' })
+        status: HttpStatusCode.FORBIDDEN_403,
+        message: 'Live is not enabled on this instance',
+        type: ServerErrorCode.LIVE_NOT_ENABLED
+      })
    }
    if (CONFIG.LIVE.ALLOW_REPLAY !== true && req.body.saveReplay === true) {
      cleanUpReqFiles(req)
-      return res.status(HttpStatusCode.FORBIDDEN_403)
+      return res.fail({
-        .json({ error: 'Saving live replay is not allowed instance' })
+        status: HttpStatusCode.FORBIDDEN_403,
+        message: 'Saving live replay is not enabled on this instance',
+        type: ServerErrorCode.LIVE_NOT_ALLOWING_REPLAY
+      })
    }
    if (req.body.permanentLive && req.body.saveReplay) {
      cleanUpReqFiles(req)
-      return res.status(HttpStatusCode.BAD_REQUEST_400)
+      return res.fail({ message: 'Cannot set this live as permanent while saving its replay' })
-        .json({ error: 'Cannot set this live as permanent while saving its replay' })
    }
    const user = res.locals.oauth.token.User
@@ -90,11 +108,11 @@ const videoLiveAddValidator = getCommonVideoEditAttributes().concat([
      if (totalInstanceLives >= CONFIG.LIVE.MAX_INSTANCE_LIVES) {
        cleanUpReqFiles(req)
-        return res.status(HttpStatusCode.FORBIDDEN_403)
+        return res.fail({
-          .json({
+          status: HttpStatusCode.FORBIDDEN_403,
-            code: ServerErrorCode.MAX_INSTANCE_LIVES_LIMIT_REACHED,
+          message: 'Cannot create this live because the max instance lives limit is reached.',
-            error: 'Cannot create this live because the max instance lives limit is reached.'
+          type: ServerErrorCode.MAX_INSTANCE_LIVES_LIMIT_REACHED
-          })
+        })
      }
    }
@@ -104,11 +122,11 @@ const videoLiveAddValidator = getCommonVideoEditAttributes().concat([
      if (totalUserLives >= CONFIG.LIVE.MAX_USER_LIVES) {
        cleanUpReqFiles(req)
-        return res.status(HttpStatusCode.FORBIDDEN_403)
+        return res.fail({
-          .json({
+          status: HttpStatusCode.FORBIDDEN_403,
-            code: ServerErrorCode.MAX_USER_LIVES_LIMIT_REACHED,
+          message: 'Cannot create this live because the max user lives limit is reached.',
-            error: 'Cannot create this live because the max user lives limit is reached.'
+          type: ServerErrorCode.MAX_USER_LIVES_LIMIT_REACHED
-          })
+        })
      }
    }
@@ -130,18 +148,18 @@ const videoLiveUpdateValidator = [
    if (areValidationErrors(req, res)) return
    if (req.body.permanentLive && req.body.saveReplay) {
-      return res.status(HttpStatusCode.BAD_REQUEST_400)
+      return res.fail({ message: 'Cannot set this live as permanent while saving its replay' })
-        .json({ error: 'Cannot set this live as permanent while saving its replay' })
    }
    if (CONFIG.LIVE.ALLOW_REPLAY !== true && req.body.saveReplay === true) {
-      return res.status(HttpStatusCode.FORBIDDEN_403)
+      return res.fail({
-        .json({ error: 'Saving live replay is not allowed instance' })
+        status: HttpStatusCode.FORBIDDEN_403,
+        message: 'Saving live replay is not allowed instance'
+      })
    }
    if (res.locals.videoAll.state !== VideoState.WAITING_FOR_LIVE) {
-      return res.status(HttpStatusCode.BAD_REQUEST_400)
+      return res.fail({ message: 'Cannot update a live that has already started' })
-        .json({ error: 'Cannot update a live that has already started' })
    }
    // Check the user can manage the live
@@ -177,9 +195,10 @@ async function isLiveVideoAccepted (req: express.Request, res: express.Response)
  if (!acceptedResult || acceptedResult.accepted !== true) {
    logger.info('Refused local live video.', { acceptedResult, acceptParameters })
-    res.status(HttpStatusCode.FORBIDDEN_403)
+    res.fail({
-       .json({ error: acceptedResult.errorMessage || 'Refused local live video' })
+      status: HttpStatusCode.FORBIDDEN_403,
+      message: acceptedResult.errorMessage || 'Refused local live video'
+    })
    return false
  }
diff --git a/server/middlewares/validators/videos/video-ownership-changes.ts b/server/middlewares/validators/videos/video-ownership-changes.ts
new file mode 100644
index 000000000..54ac46c99
--- /dev/null
+++ b/server/middlewares/validators/videos/video-ownership-changes.ts
@@ -0,0 +1,121 @@
+import * as express from 'express'
+import { param } from 'express-validator'
+import { isIdValid } from '@server/helpers/custom-validators/misc'
+import { checkUserCanTerminateOwnershipChange } from '@server/helpers/custom-validators/video-ownership'
+import { logger } from '@server/helpers/logger'
+import { isAbleToUploadVideo } from '@server/lib/user'
+import { AccountModel } from '@server/models/account/account'
+import { MVideoWithAllFiles } from '@server/types/models'
+import { HttpStatusCode } from '@shared/core-utils'
+import { ServerErrorCode, UserRight, VideoChangeOwnershipAccept, VideoChangeOwnershipStatus, VideoState } from '@shared/models'
+import {
+  areValidationErrors,
+  checkUserCanManageVideo,
+  doesChangeVideoOwnershipExist,
+  doesVideoChannelOfAccountExist,
+  doesVideoExist,
+  isValidVideoIdParam
+} from '../shared'
+const videosChangeOwnershipValidator = [
+  isValidVideoIdParam('videoId'),
+  async (req: express.Request, res: express.Response, next: express.NextFunction) => {
+    logger.debug('Checking changeOwnership parameters', { parameters: req.params })
+    if (areValidationErrors(req, res)) return
+    if (!await doesVideoExist(req.params.videoId, res)) return
+    // Check if the user who did the request is able to change the ownership of the video
+    if (!checkUserCanManageVideo(res.locals.oauth.token.User, res.locals.videoAll, UserRight.CHANGE_VIDEO_OWNERSHIP, res)) return
+    const nextOwner = await AccountModel.loadLocalByName(req.body.username)
+    if (!nextOwner) {
+      res.fail({ message: 'Changing video ownership to a remote account is not supported yet' })
+      return
+    }
+    res.locals.nextOwner = nextOwner
+    return next()
+  }
+]
+const videosTerminateChangeOwnershipValidator = [
+  param('id')
+    .custom(isIdValid).withMessage('Should have a valid id'),
+  async (req: express.Request, res: express.Response, next: express.NextFunction) => {
+    logger.debug('Checking changeOwnership parameters', { parameters: req.params })
+    if (areValidationErrors(req, res)) return
+    if (!await doesChangeVideoOwnershipExist(req.params.id, res)) return
+    // Check if the user who did the request is able to change the ownership of the video
+    if (!checkUserCanTerminateOwnershipChange(res.locals.oauth.token.User, res.locals.videoChangeOwnership, res)) return
+    const videoChangeOwnership = res.locals.videoChangeOwnership
+    if (videoChangeOwnership.status !== VideoChangeOwnershipStatus.WAITING) {
+      res.fail({
+        status: HttpStatusCode.FORBIDDEN_403,
+        message: 'Ownership already accepted or refused'
+      })
+      return
+    }
+    return next()
+  }
+]
+const videosAcceptChangeOwnershipValidator = [
+  async (req: express.Request, res: express.Response, next: express.NextFunction) => {
+    const body = req.body as VideoChangeOwnershipAccept
+    if (!await doesVideoChannelOfAccountExist(body.channelId, res.locals.oauth.token.User, res)) return
+    const videoChangeOwnership = res.locals.videoChangeOwnership
+    const video = videoChangeOwnership.Video
+    if (!await checkCanAccept(video, res)) return
+    return next()
+  }
+]
+export {
+  videosChangeOwnershipValidator,
+  videosTerminateChangeOwnershipValidator,
+  videosAcceptChangeOwnershipValidator
+}
+// ---------------------------------------------------------------------------
+async function checkCanAccept (video: MVideoWithAllFiles, res: express.Response): Promise<boolean> {
+  if (video.isLive) {
+    if (video.state !== VideoState.WAITING_FOR_LIVE) {
+      res.fail({
+        status: HttpStatusCode.BAD_REQUEST_400,
+        message: 'You can accept an ownership change of a published live.'
+      })
+      return false
+    }
+    return true
+  }
+  const user = res.locals.oauth.token.User
+  if (!await isAbleToUploadVideo(user.id, video.getMaxQualityFile().size)) {
+    res.fail({
+      status: HttpStatusCode.PAYLOAD_TOO_LARGE_413,
+      message: 'The user video quota is exceeded with this video.',
+      type: ServerErrorCode.QUOTA_REACHED
+    })
+    return false
+  }
+  return true
+}
diff --git a/server/middlewares/validators/videos/video-playlists.ts b/server/middlewares/validators/videos/video-playlists.ts
index c872d045e..5ee7ee0ce 100644
--- a/server/middlewares/validators/videos/video-playlists.ts
+++ b/server/middlewares/validators/videos/video-playlists.ts
@@ -11,6 +11,7 @@ import {
  isIdOrUUIDValid,
  isIdValid,
  isUUIDValid,
+  toCompleteUUID,
  toIntArray,
  toIntOrNull,
  toValueOrNull
@@ -25,12 +26,18 @@ import {
 import { isVideoImage } from '../../../helpers/custom-validators/videos'
 import { cleanUpReqFiles } from '../../../helpers/express-utils'
 import { logger } from '../../../helpers/logger'
-import { doesVideoChannelIdExist, doesVideoExist, doesVideoPlaylistExist, VideoPlaylistFetchType } from '../../../helpers/middlewares'
 import { CONSTRAINTS_FIELDS } from '../../../initializers/constants'
 import { VideoPlaylistElementModel } from '../../../models/video/video-playlist-element'
 import { MVideoPlaylist } from '../../../types/models/video/video-playlist'
 import { authenticatePromiseIfNeeded } from '../../auth'
-import { areValidationErrors } from '../utils'
+import {
+  areValidationErrors,
+  doesVideoChannelIdExist,
+  doesVideoExist,
+  doesVideoPlaylistExist,
+  isValidPlaylistIdParam,
+  VideoPlaylistFetchType
+} from '../shared'
 const videoPlaylistsAddValidator = getCommonPlaylistEditAttributes().concat([
  body('displayName')
@@ -44,10 +51,13 @@ const videoPlaylistsAddValidator = getCommonPlaylistEditAttributes().concat([
    const body: VideoPlaylistCreate = req.body
    if (body.videoChannelId && !await doesVideoChannelIdExist(body.videoChannelId, res)) return cleanUpReqFiles(req)
-    if (body.privacy === VideoPlaylistPrivacy.PUBLIC && !body.videoChannelId) {
+    if (
+      !body.videoChannelId &&
+      (body.privacy === VideoPlaylistPrivacy.PUBLIC || body.privacy === VideoPlaylistPrivacy.UNLISTED)
+    ) {
      cleanUpReqFiles(req)
-      return res.status(HttpStatusCode.BAD_REQUEST_400)
-                .json({ error: 'Cannot set "public" a playlist that is not assigned to a channel.' })
+      return res.fail({ message: 'Cannot set "public" or "unlisted" a playlist that is not assigned to a channel.' })
    }
    return next()
@@ -55,8 +65,7 @@ const videoPlaylistsAddValidator = getCommonPlaylistEditAttributes().concat([
 ])
 const videoPlaylistsUpdateValidator = getCommonPlaylistEditAttributes().concat([
-  param('playlistId')
+  isValidPlaylistIdParam('playlistId'),
-    .custom(isIdOrUUIDValid).withMessage('Should have a valid playlist id/uuid'),
  body('displayName')
    .optional()
@@ -85,14 +94,14 @@ const videoPlaylistsUpdateValidator = getCommonPlaylistEditAttributes().concat([
      )
    ) {
      cleanUpReqFiles(req)
-      return res.status(HttpStatusCode.BAD_REQUEST_400)
-                .json({ error: 'Cannot set "public" a playlist that is not assigned to a channel.' })
+      return res.fail({ message: 'Cannot set "public" a playlist that is not assigned to a channel.' })
    }
    if (videoPlaylist.type === VideoPlaylistType.WATCH_LATER) {
      cleanUpReqFiles(req)
-      return res.status(HttpStatusCode.BAD_REQUEST_400)
-                .json({ error: 'Cannot update a watch later playlist.' })
+      return res.fail({ message: 'Cannot update a watch later playlist.' })
    }
    if (body.videoChannelId && !await doesVideoChannelIdExist(body.videoChannelId, res)) return cleanUpReqFiles(req)
@@ -102,8 +111,7 @@ const videoPlaylistsUpdateValidator = getCommonPlaylistEditAttributes().concat([
 ])
 const videoPlaylistsDeleteValidator = [
-  param('playlistId')
+  isValidPlaylistIdParam('playlistId'),
-    .custom(isIdOrUUIDValid).withMessage('Should have a valid playlist id/uuid'),
  async (req: express.Request, res: express.Response, next: express.NextFunction) => {
    logger.debug('Checking videoPlaylistsDeleteValidator parameters', { parameters: req.params })
@@ -114,8 +122,7 @@ const videoPlaylistsDeleteValidator = [
    const videoPlaylist = getPlaylist(res)
    if (videoPlaylist.type === VideoPlaylistType.WATCH_LATER) {
-      return res.status(HttpStatusCode.BAD_REQUEST_400)
+      return res.fail({ message: 'Cannot delete a watch later playlist.' })
-                .json({ error: 'Cannot delete a watch later playlist.' })
    }
    if (!checkUserCanManageVideoPlaylist(res.locals.oauth.token.User, videoPlaylist, UserRight.REMOVE_ANY_VIDEO_PLAYLIST, res)) {
@@ -128,8 +135,7 @@ const videoPlaylistsDeleteValidator = [
 const videoPlaylistsGetValidator = (fetchType: VideoPlaylistFetchType) => {
  return [
-    param('playlistId')
+    isValidPlaylistIdParam('playlistId'),
-      .custom(isIdOrUUIDValid).withMessage('Should have a valid playlist id/uuid'),
    async (req: express.Request, res: express.Response, next: express.NextFunction) => {
      logger.debug('Checking videoPlaylistsGetValidator parameters', { parameters: req.params })
@@ -144,7 +150,10 @@ const videoPlaylistsGetValidator = (fetchType: VideoPlaylistFetchType) => {
      if (videoPlaylist.privacy === VideoPlaylistPrivacy.UNLISTED) {
        if (isUUIDValid(req.params.playlistId)) return next()
-        return res.status(HttpStatusCode.NOT_FOUND_404).end()
+        return res.fail({
+          status: HttpStatusCode.NOT_FOUND_404,
+          message: 'Playlist not found'
+        })
      }
      if (videoPlaylist.privacy === VideoPlaylistPrivacy.PRIVATE) {
@@ -156,8 +165,10 @@ const videoPlaylistsGetValidator = (fetchType: VideoPlaylistFetchType) => {
          !user ||
          (videoPlaylist.OwnerAccount.id !== user.Account.id && !user.hasRight(UserRight.UPDATE_ANY_VIDEO_PLAYLIST))
        ) {
-          return res.status(HttpStatusCode.FORBIDDEN_403)
+          return res.fail({
-                    .json({ error: 'Cannot get this private video playlist.' })
+            status: HttpStatusCode.FORBIDDEN_403,
+            message: 'Cannot get this private video playlist.'
+          })
        }
        return next()
@@ -181,9 +192,10 @@ const videoPlaylistsSearchValidator = [
 ]
 const videoPlaylistsAddVideoValidator = [
-  param('playlistId')
+  isValidPlaylistIdParam('playlistId'),
-    .custom(isIdOrUUIDValid).withMessage('Should have a valid playlist id/uuid'),
  body('videoId')
+    .customSanitizer(toCompleteUUID)
    .custom(isIdOrUUIDValid).withMessage('Should have a valid video id/uuid'),
  body('startTimestamp')
    .optional()
@@ -211,9 +223,9 @@ const videoPlaylistsAddVideoValidator = [
 ]
 const videoPlaylistsUpdateOrRemoveVideoValidator = [
-  param('playlistId')
+  isValidPlaylistIdParam('playlistId'),
-    .custom(isIdOrUUIDValid).withMessage('Should have a valid playlist id/uuid'),
  param('playlistElementId')
+    .customSanitizer(toCompleteUUID)
    .custom(isIdValid).withMessage('Should have an element id/uuid'),
  body('startTimestamp')
    .optional()
@@ -233,10 +245,10 @@ const videoPlaylistsUpdateOrRemoveVideoValidator = [
    const videoPlaylistElement = await VideoPlaylistElementModel.loadById(req.params.playlistElementId)
    if (!videoPlaylistElement) {
-      res.status(HttpStatusCode.NOT_FOUND_404)
+      res.fail({
-         .json({ error: 'Video playlist element not found' })
+        status: HttpStatusCode.NOT_FOUND_404,
-         .end()
+        message: 'Video playlist element not found'
+      })
      return
    }
    res.locals.videoPlaylistElement = videoPlaylistElement
@@ -248,8 +260,7 @@ const videoPlaylistsUpdateOrRemoveVideoValidator = [
 ]
 const videoPlaylistElementAPGetValidator = [
-  param('playlistId')
+  isValidPlaylistIdParam('playlistId'),
-    .custom(isIdOrUUIDValid).withMessage('Should have a valid playlist id/uuid'),
  param('playlistElementId')
    .custom(isIdValid).withMessage('Should have an playlist element id'),
@@ -263,15 +274,18 @@ const videoPlaylistElementAPGetValidator = [
    const videoPlaylistElement = await VideoPlaylistElementModel.loadByPlaylistAndElementIdForAP(playlistId, playlistElementId)
    if (!videoPlaylistElement) {
-      res.status(HttpStatusCode.NOT_FOUND_404)
+      res.fail({
-         .json({ error: 'Video playlist element not found' })
+        status: HttpStatusCode.NOT_FOUND_404,
-         .end()
+        message: 'Video playlist element not found'
+      })
      return
    }
    if (videoPlaylistElement.VideoPlaylist.privacy === VideoPlaylistPrivacy.PRIVATE) {
-      return res.status(HttpStatusCode.FORBIDDEN_403).end()
+      return res.fail({
+        status: HttpStatusCode.FORBIDDEN_403,
+        message: 'Cannot get this private video playlist.'
+      })
    }
    res.locals.videoPlaylistElementAP = videoPlaylistElement
@@ -281,8 +295,7 @@ const videoPlaylistElementAPGetValidator = [
 ]
 const videoPlaylistsReorderVideosValidator = [
-  param('playlistId')
+  isValidPlaylistIdParam('playlistId'),
-    .custom(isIdOrUUIDValid).withMessage('Should have a valid playlist id/uuid'),
  body('startPosition')
    .isInt({ min: 1 }).withMessage('Should have a valid start position'),
  body('insertAfterPosition')
@@ -307,18 +320,12 @@ const videoPlaylistsReorderVideosValidator = [
    const reorderLength: number = req.body.reorderLength
    if (startPosition >= nextPosition || insertAfterPosition >= nextPosition) {
-      res.status(HttpStatusCode.BAD_REQUEST_400)
+      res.fail({ message: `Start position or insert after position exceed the playlist limits (max: ${nextPosition - 1})` })
-         .json({ error: `Start position or insert after position exceed the playlist limits (max: ${nextPosition - 1})` })
-         .end()
      return
    }
    if (reorderLength && reorderLength + startPosition > nextPosition) {
-      res.status(HttpStatusCode.BAD_REQUEST_400)
+      res.fail({ message: `Reorder length with this start position exceeds the playlist limits (max: ${nextPosition - startPosition})` })
-         .json({ error: `Reorder length with this start position exceeds the playlist limits (max: ${nextPosition - startPosition})` })
-         .end()
      return
    }
@@ -401,10 +408,10 @@ function getCommonPlaylistEditAttributes () {
 function checkUserCanManageVideoPlaylist (user: MUserAccountId, videoPlaylist: MVideoPlaylist, right: UserRight, res: express.Response) {
  if (videoPlaylist.isOwned() === false) {
-    res.status(HttpStatusCode.FORBIDDEN_403)
+    res.fail({
-       .json({ error: 'Cannot manage video playlist of another server.' })
+      status: HttpStatusCode.FORBIDDEN_403,
-       .end()
+      message: 'Cannot manage video playlist of another server.'
+    })
    return false
  }
@@ -412,10 +419,10 @@ function checkUserCanManageVideoPlaylist (user: MUserAccountId, videoPlaylist: M
  // The user can delete it if s/he is an admin
  // Or if s/he is the video playlist's owner
  if (user.hasRight(right) === false && videoPlaylist.ownerAccountId !== user.Account.id) {
-    res.status(HttpStatusCode.FORBIDDEN_403)
+    res.fail({
-       .json({ error: 'Cannot manage video playlist of another user' })
+      status: HttpStatusCode.FORBIDDEN_403,
-       .end()
+      message: 'Cannot manage video playlist of another user'
+    })
    return false
  }
diff --git a/server/middlewares/validators/videos/video-rates.ts b/server/middlewares/validators/videos/video-rates.ts
index 01bdef25f..5d5dfb222 100644
--- a/server/middlewares/validators/videos/video-rates.ts
+++ b/server/middlewares/validators/videos/video-rates.ts
@@ -1,18 +1,18 @@
 import * as express from 'express'
 import { body, param, query } from 'express-validator'
-import { isIdOrUUIDValid, isIdValid } from '../../../helpers/custom-validators/misc'
+import { HttpStatusCode } from '../../../../shared/core-utils/miscs/http-error-codes'
+import { VideoRateType } from '../../../../shared/models/videos'
+import { isAccountNameValid } from '../../../helpers/custom-validators/accounts'
+import { isIdValid } from '../../../helpers/custom-validators/misc'
 import { isRatingValid } from '../../../helpers/custom-validators/video-rates'
 import { isVideoRatingTypeValid } from '../../../helpers/custom-validators/videos'
 import { logger } from '../../../helpers/logger'
-import { areValidationErrors } from '../utils'
 import { AccountVideoRateModel } from '../../../models/account/account-video-rate'
-import { VideoRateType } from '../../../../shared/models/videos'
+import { areValidationErrors, doesVideoExist, isValidVideoIdParam } from '../shared'
-import { isAccountNameValid } from '../../../helpers/custom-validators/accounts'
-import { doesVideoExist } from '../../../helpers/middlewares'
-import { HttpStatusCode } from '../../../../shared/core-utils/miscs/http-error-codes'
 const videoUpdateRateValidator = [
-  param('id').custom(isIdOrUUIDValid).not().isEmpty().withMessage('Should have a valid id'),
+  isValidVideoIdParam('id'),
  body('rating').custom(isVideoRatingTypeValid).withMessage('Should have a valid rate type'),
  async (req: express.Request, res: express.Response, next: express.NextFunction) => {
@@ -37,8 +37,10 @@ const getAccountVideoRateValidatorFactory = function (rateType: VideoRateType) {
      const rate = await AccountVideoRateModel.loadLocalAndPopulateVideo(rateType, req.params.name, +req.params.videoId)
      if (!rate) {
-        return res.status(HttpStatusCode.NOT_FOUND_404)
+        return res.fail({
-                  .json({ error: 'Video rate not found' })
+          status: HttpStatusCode.NOT_FOUND_404,
+          message: 'Video rate not found'
+        })
      }
      res.locals.accountVideoRate = rate
diff --git a/server/middlewares/validators/videos/video-shares.ts b/server/middlewares/validators/videos/video-shares.ts
index f0d8e0c36..7e54b6fc0 100644
--- a/server/middlewares/validators/videos/video-shares.ts
+++ b/server/middlewares/validators/videos/video-shares.ts
@@ -1,15 +1,16 @@
 import * as express from 'express'
 import { param } from 'express-validator'
-import { isIdOrUUIDValid, isIdValid } from '../../../helpers/custom-validators/misc'
+import { HttpStatusCode } from '../../../../shared/core-utils/miscs/http-error-codes'
+import { isIdValid } from '../../../helpers/custom-validators/misc'
 import { logger } from '../../../helpers/logger'
 import { VideoShareModel } from '../../../models/video/video-share'
-import { areValidationErrors } from '../utils'
+import { areValidationErrors, doesVideoExist, isValidVideoIdParam } from '../shared'
-import { doesVideoExist } from '../../../helpers/middlewares'
-import { HttpStatusCode } from '../../../../shared/core-utils/miscs/http-error-codes'
 const videosShareValidator = [
-  param('id').custom(isIdOrUUIDValid).not().isEmpty().withMessage('Should have a valid id'),
+  isValidVideoIdParam('id'),
-  param('actorId').custom(isIdValid).not().isEmpty().withMessage('Should have a valid actor id'),
+  param('actorId')
+    .custom(isIdValid).not().isEmpty().withMessage('Should have a valid actor id'),
  async (req: express.Request, res: express.Response, next: express.NextFunction) => {
    logger.debug('Checking videoShare parameters', { parameters: req.params })
diff --git a/server/middlewares/validators/videos/video-watch.ts b/server/middlewares/validators/videos/video-watch.ts
index 29ce0dab6..43306f7cd 100644
--- a/server/middlewares/validators/videos/video-watch.ts
+++ b/server/middlewares/validators/videos/video-watch.ts
@@ -1,13 +1,13 @@
-import { body, param } from 'express-validator'
 import * as express from 'express'
-import { isIdOrUUIDValid, toIntOrNull } from '../../../helpers/custom-validators/misc'
+import { body } from 'express-validator'
-import { areValidationErrors } from '../utils'
-import { logger } from '../../../helpers/logger'
-import { doesVideoExist } from '../../../helpers/middlewares'
 import { HttpStatusCode } from '../../../../shared/core-utils/miscs/http-error-codes'
+import { toIntOrNull } from '../../../helpers/custom-validators/misc'
+import { logger } from '../../../helpers/logger'
+import { areValidationErrors, doesVideoExist, isValidVideoIdParam } from '../shared'
 const videoWatchingValidator = [
-  param('videoId').custom(isIdOrUUIDValid).not().isEmpty().withMessage('Should have a valid id'),
+  isValidVideoIdParam('videoId'),
  body('currentTime')
    .customSanitizer(toIntOrNull)
    .isInt().withMessage('Should have correct current time'),
@@ -21,7 +21,10 @@ const videoWatchingValidator = [
    const user = res.locals.oauth.token.User
    if (user.videosHistoryEnabled === false) {
      logger.warn('Cannot set videos to watch by user %d: videos history is disabled.', user.id)
-      return res.status(HttpStatusCode.CONFLICT_409).end()
+      return res.fail({
+        status: HttpStatusCode.CONFLICT_409,
+        message: 'Video history is disabled'
+      })
    }
    return next()
diff --git a/server/middlewares/validators/videos/videos.ts b/server/middlewares/validators/videos/videos.ts
index d26bcd4a6..49e10e2b5 100644
--- a/server/middlewares/validators/videos/videos.ts
+++ b/server/middlewares/validators/videos/videos.ts
@@ -4,16 +4,14 @@ import { getResumableUploadPath } from '@server/helpers/upload'
 import { isAbleToUploadVideo } from '@server/lib/user'
 import { getServerActor } from '@server/models/application/application'
 import { ExpressPromiseHandler } from '@server/types/express'
-import { MUserAccountId, MVideoWithRights } from '@server/types/models'
+import { MUserAccountId, MVideoFullLight } from '@server/types/models'
-import { ServerErrorCode, UserRight, VideoChangeOwnershipStatus, VideoPrivacy } from '../../../../shared'
+import { ServerErrorCode, UserRight, VideoPrivacy } from '../../../../shared'
 import { HttpStatusCode } from '../../../../shared/core-utils/miscs/http-error-codes'
-import { VideoChangeOwnershipAccept } from '../../../../shared/models/videos/video-change-ownership-accept.model'
 import {
  exists,
  isBooleanValid,
  isDateValid,
  isFileFieldValid,
-  isIdOrUUIDValid,
  isIdValid,
  isUUIDValid,
  toArray,
@@ -22,7 +20,6 @@ import {
  toValueOrNull
 } from '../../../helpers/custom-validators/misc'
 import { isBooleanBothQueryValid, isNumberArray, isStringArray } from '../../../helpers/custom-validators/search'
-import { checkUserCanTerminateOwnershipChange, doesChangeVideoOwnershipExist } from '../../../helpers/custom-validators/video-ownership'
 import {
  isScheduleVideoUpdatePrivacyValid,
  isVideoCategoryValid,
@@ -42,22 +39,22 @@ import {
 import { cleanUpReqFiles } from '../../../helpers/express-utils'
 import { getDurationFromVideoFile } from '../../../helpers/ffprobe-utils'
 import { logger } from '../../../helpers/logger'
-import {
-  checkUserCanManageVideo,
-  doesVideoChannelOfAccountExist,
-  doesVideoExist,
-  doesVideoFileOfVideoExist
-} from '../../../helpers/middlewares'
 import { deleteFileAndCatch } from '../../../helpers/utils'
 import { getVideoWithAttributes } from '../../../helpers/video'
 import { CONFIG } from '../../../initializers/config'
 import { CONSTRAINTS_FIELDS, OVERVIEWS } from '../../../initializers/constants'
 import { isLocalVideoAccepted } from '../../../lib/moderation'
 import { Hooks } from '../../../lib/plugins/hooks'
-import { AccountModel } from '../../../models/account/account'
 import { VideoModel } from '../../../models/video/video'
 import { authenticatePromiseIfNeeded } from '../../auth'
-import { areValidationErrors } from '../utils'
+import {
+  areValidationErrors,
+  checkUserCanManageVideo,
+  doesVideoChannelOfAccountExist,
+  doesVideoExist,
+  doesVideoFileOfVideoExist,
+  isValidVideoIdParam
+} from '../shared'
 const videosAddLegacyValidator = getCommonVideoEditAttributes().concat([
  body('videofile')
@@ -65,8 +62,9 @@ const videosAddLegacyValidator = getCommonVideoEditAttributes().concat([
    .withMessage('Should have a file'),
  body('name')
    .trim()
-    .custom(isVideoNameValid)
+    .custom(isVideoNameValid).withMessage(
-    .withMessage('Should have a valid name'),
+      `Should have a video name between ${CONSTRAINTS_FIELDS.VIDEOS.NAME.min} and ${CONSTRAINTS_FIELDS.VIDEOS.NAME.max} characters long`
+    ),
  body('channelId')
    .customSanitizer(toIntOrNull)
    .custom(isIdValid).withMessage('Should have correct video channel id'),
@@ -87,9 +85,11 @@ const videosAddLegacyValidator = getCommonVideoEditAttributes().concat([
      if (!videoFile.duration) await addDurationToVideo(videoFile)
    } catch (err) {
      logger.error('Invalid input file in videosAddLegacyValidator.', { err })
-      res.status(HttpStatusCode.UNPROCESSABLE_ENTITY_422)
-         .json({ error: 'Video file unreadable.' })
+      res.fail({
+        status: HttpStatusCode.UNPROCESSABLE_ENTITY_422,
+        message: 'Video file unreadable.'
+      })
      return cleanUpReqFiles(req)
    }
@@ -117,9 +117,11 @@ const videosAddResumableValidator = [
      if (!file.duration) await addDurationToVideo(file)
    } catch (err) {
      logger.error('Invalid input file in videosAddResumableValidator.', { err })
-      res.status(HttpStatusCode.UNPROCESSABLE_ENTITY_422)
-         .json({ error: 'Video file unreadable.' })
+      res.fail({
+        status: HttpStatusCode.UNPROCESSABLE_ENTITY_422,
+        message: 'Video file unreadable.'
+      })
      return cleanup()
    }
@@ -146,8 +148,9 @@ const videosAddResumableInitValidator = getCommonVideoEditAttributes().concat([
    .withMessage('Should have a valid filename'),
  body('name')
    .trim()
-    .custom(isVideoNameValid)
+    .custom(isVideoNameValid).withMessage(
-    .withMessage('Should have a valid name'),
+      `Should have a video name between ${CONSTRAINTS_FIELDS.VIDEOS.NAME.min} and ${CONSTRAINTS_FIELDS.VIDEOS.NAME.max} characters long`
+    ),
  body('channelId')
    .customSanitizer(toIntOrNull)
    .custom(isIdValid).withMessage('Should have correct video channel id'),
@@ -192,11 +195,14 @@ const videosAddResumableInitValidator = getCommonVideoEditAttributes().concat([
 ])
 const videosUpdateValidator = getCommonVideoEditAttributes().concat([
-  param('id').custom(isIdOrUUIDValid).not().isEmpty().withMessage('Should have a valid id'),
+  isValidVideoIdParam('id'),
  body('name')
    .optional()
    .trim()
-    .custom(isVideoNameValid).withMessage('Should have a valid name'),
+    .custom(isVideoNameValid).withMessage(
+      `Should have a video name between ${CONSTRAINTS_FIELDS.VIDEOS.NAME.min} and ${CONSTRAINTS_FIELDS.VIDEOS.NAME.max} characters long`
+    ),
  body('channelId')
    .optional()
    .customSanitizer(toIntOrNull)
@@ -238,20 +244,22 @@ async function checkVideoFollowConstraints (req: express.Request, res: express.R
  const serverActor = await getServerActor()
  if (await VideoModel.checkVideoHasInstanceFollow(video.id, serverActor.id) === true) return next()
-  return res.status(HttpStatusCode.FORBIDDEN_403)
+  return res.fail({
-            .json({
+    status: HttpStatusCode.FORBIDDEN_403,
-              errorCode: ServerErrorCode.DOES_NOT_RESPECT_FOLLOW_CONSTRAINTS,
+    message: 'Cannot get this video regarding follow constraints',
-              error: 'Cannot get this video regarding follow constraints.',
+    type: ServerErrorCode.DOES_NOT_RESPECT_FOLLOW_CONSTRAINTS,
-              originUrl: video.url
+    data: {
-            })
+      originUrl: video.url
+    }
+  })
 }
 const videosCustomGetValidator = (
-  fetchType: 'all' | 'only-video' | 'only-video-with-rights' | 'only-immutable-attributes',
+  fetchType: 'for-api' | 'all' | 'only-video' | 'only-immutable-attributes',
  authenticateInQuery = false
 ) => {
  return [
-    param('id').custom(isIdOrUUIDValid).not().isEmpty().withMessage('Should have a valid id'),
+    isValidVideoIdParam('id'),
    async (req: express.Request, res: express.Response, next: express.NextFunction) => {
      logger.debug('Checking videosGet parameters', { parameters: req.params })
@@ -262,7 +270,7 @@ const videosCustomGetValidator = (
      // Controllers does not need to check video rights
      if (fetchType === 'only-immutable-attributes') return next()
-      const video = getVideoWithAttributes(res) as MVideoWithRights
+      const video = getVideoWithAttributes(res) as MVideoFullLight
      // Video private or blacklisted
      if (video.requiresAuth()) {
@@ -270,10 +278,12 @@ const videosCustomGetValidator = (
        const user = res.locals.oauth ? res.locals.oauth.token.User : null
-        // Only the owner or a user that have blacklist rights can see the video
+        // Only the owner or a user that have blocklist rights can see the video
        if (!user || !user.canGetVideo(video)) {
-          return res.status(HttpStatusCode.FORBIDDEN_403)
+          return res.fail({
-                    .json({ error: 'Cannot get this private/internal or blacklisted video.' })
+            status: HttpStatusCode.FORBIDDEN_403,
+            message: 'Cannot get this private/internal or blocklisted video'
+          })
        }
        return next()
@@ -287,7 +297,10 @@ const videosCustomGetValidator = (
        if (isUUIDValid(req.params.id)) return next()
        // Don't leak this unlisted video
-        return res.status(HttpStatusCode.NOT_FOUND_404).end()
+        return res.fail({
+          status: HttpStatusCode.NOT_FOUND_404,
+          message: 'Video not found'
+        })
      }
    }
  ]
@@ -297,8 +310,10 @@ const videosGetValidator = videosCustomGetValidator('all')
 const videosDownloadValidator = videosCustomGetValidator('all', true)
 const videoFileMetadataGetValidator = getCommonVideoEditAttributes().concat([
-  param('id').custom(isIdOrUUIDValid).not().isEmpty().withMessage('Should have a valid id'),
+  isValidVideoIdParam('id'),
-  param('videoFileId').custom(isIdValid).not().isEmpty().withMessage('Should have a valid videoFileId'),
+  param('videoFileId')
+    .custom(isIdValid).not().isEmpty().withMessage('Should have a valid videoFileId'),
  async (req: express.Request, res: express.Response, next: express.NextFunction) => {
    logger.debug('Checking videoFileMetadataGet parameters', { parameters: req.params })
@@ -311,7 +326,7 @@ const videoFileMetadataGetValidator = getCommonVideoEditAttributes().concat([
 ])
 const videosRemoveValidator = [
-  param('id').custom(isIdOrUUIDValid).not().isEmpty().withMessage('Should have a valid id'),
+  isValidVideoIdParam('id'),
  async (req: express.Request, res: express.Response, next: express.NextFunction) => {
    logger.debug('Checking videosRemove parameters', { parameters: req.params })
@@ -326,74 +341,6 @@ const videosRemoveValidator = [
  }
 ]
-const videosChangeOwnershipValidator = [
-  param('videoId').custom(isIdOrUUIDValid).not().isEmpty().withMessage('Should have a valid id'),
-  async (req: express.Request, res: express.Response, next: express.NextFunction) => {
-    logger.debug('Checking changeOwnership parameters', { parameters: req.params })
-    if (areValidationErrors(req, res)) return
-    if (!await doesVideoExist(req.params.videoId, res)) return
-    // Check if the user who did the request is able to change the ownership of the video
-    if (!checkUserCanManageVideo(res.locals.oauth.token.User, res.locals.videoAll, UserRight.CHANGE_VIDEO_OWNERSHIP, res)) return
-    const nextOwner = await AccountModel.loadLocalByName(req.body.username)
-    if (!nextOwner) {
-      res.status(HttpStatusCode.BAD_REQUEST_400)
-        .json({ error: 'Changing video ownership to a remote account is not supported yet' })
-      return
-    }
-    res.locals.nextOwner = nextOwner
-    return next()
-  }
-]
-const videosTerminateChangeOwnershipValidator = [
-  param('id').custom(isIdOrUUIDValid).not().isEmpty().withMessage('Should have a valid id'),
-  async (req: express.Request, res: express.Response, next: express.NextFunction) => {
-    logger.debug('Checking changeOwnership parameters', { parameters: req.params })
-    if (areValidationErrors(req, res)) return
-    if (!await doesChangeVideoOwnershipExist(req.params.id, res)) return
-    // Check if the user who did the request is able to change the ownership of the video
-    if (!checkUserCanTerminateOwnershipChange(res.locals.oauth.token.User, res.locals.videoChangeOwnership, res)) return
-    const videoChangeOwnership = res.locals.videoChangeOwnership
-    if (videoChangeOwnership.status !== VideoChangeOwnershipStatus.WAITING) {
-      res.status(HttpStatusCode.FORBIDDEN_403)
-         .json({ error: 'Ownership already accepted or refused' })
-      return
-    }
-    return next()
-  }
-]
-const videosAcceptChangeOwnershipValidator = [
-  async (req: express.Request, res: express.Response, next: express.NextFunction) => {
-    const body = req.body as VideoChangeOwnershipAccept
-    if (!await doesVideoChannelOfAccountExist(body.channelId, res.locals.oauth.token.User, res)) return
-    const user = res.locals.oauth.token.User
-    const videoChangeOwnership = res.locals.videoChangeOwnership
-    const isAble = await isAbleToUploadVideo(user.id, videoChangeOwnership.Video.getMaxQualityFile().size)
-    if (isAble === false) {
-      res.status(HttpStatusCode.PAYLOAD_TOO_LARGE_413)
-        .json({ error: 'The user video quota is exceeded with this video.' })
-      return
-    }
-    return next()
-  }
-]
 const videosOverviewValidator = [
  query('page')
    .optional()
@@ -455,7 +402,11 @@ function getCommonVideoEditAttributes () {
    body('tags')
      .optional()
      .customSanitizer(toValueOrNull)
-      .custom(isVideoTagsValid).withMessage('Should have correct tags'),
+      .custom(isVideoTagsValid)
+      .withMessage(
+        `Should have an array of up to ${CONSTRAINTS_FIELDS.VIDEOS.TAGS.max} tags between ` +
+        `${CONSTRAINTS_FIELDS.VIDEOS.TAG.min} and ${CONSTRAINTS_FIELDS.VIDEOS.TAG.max} characters each`
+      ),
    body('commentsEnabled')
      .optional()
      .customSanitizer(toBooleanOrNull)
@@ -473,7 +424,7 @@ function getCommonVideoEditAttributes () {
      .customSanitizer(toValueOrNull),
    body('scheduleUpdate.updateAt')
      .optional()
-      .custom(isDateValid).withMessage('Should have a valid schedule update date'),
+      .custom(isDateValid).withMessage('Should have a schedule update date that conforms to ISO 8601'),
    body('scheduleUpdate.privacy')
      .optional()
      .customSanitizer(toIntOrNull)
@@ -530,9 +481,10 @@ const commonVideosFiltersValidator = [
      (req.query.filter === 'all-local' || req.query.filter === 'all') &&
      (!user || user.hasRight(UserRight.SEE_ALL_VIDEOS) === false)
    ) {
-      res.status(HttpStatusCode.UNAUTHORIZED_401)
+      res.fail({
-         .json({ error: 'You are not allowed to see all local videos.' })
+        status: HttpStatusCode.UNAUTHORIZED_401,
+        message: 'You are not allowed to see all local videos.'
+      })
      return
    }
@@ -555,10 +507,6 @@ export {
  videosCustomGetValidator,
  videosRemoveValidator,
-  videosChangeOwnershipValidator,
-  videosTerminateChangeOwnershipValidator,
-  videosAcceptChangeOwnershipValidator,
  getCommonVideoEditAttributes,
  commonVideosFiltersValidator,
@@ -573,9 +521,7 @@ function areErrorsInScheduleUpdate (req: express.Request, res: express.Response)
    if (!req.body.scheduleUpdate.updateAt) {
      logger.warn('Invalid parameters: scheduleUpdate.updateAt is mandatory.')
-      res.status(HttpStatusCode.BAD_REQUEST_400)
+      res.fail({ message: 'Schedule update at is mandatory.' })
-         .json({ error: 'Schedule update at is mandatory.' })
      return true
    }
  }
@@ -597,26 +543,29 @@ async function commonVideoChecksPass (parameters: {
  if (!await doesVideoChannelOfAccountExist(req.body.channelId, user, res)) return false
  if (!isVideoFileMimeTypeValid(files)) {
-    res.status(HttpStatusCode.UNSUPPORTED_MEDIA_TYPE_415)
+    res.fail({
-        .json({
+      status: HttpStatusCode.UNSUPPORTED_MEDIA_TYPE_415,
-          error: 'This file is not supported. Please, make sure it is of the following type: ' +
+      message: 'This file is not supported. Please, make sure it is of the following type: ' +
-                CONSTRAINTS_FIELDS.VIDEOS.EXTNAME.join(', ')
+               CONSTRAINTS_FIELDS.VIDEOS.EXTNAME.join(', ')
-        })
+    })
    return false
  }
  if (!isVideoFileSizeValid(videoFileSize.toString())) {
-    res.status(HttpStatusCode.PAYLOAD_TOO_LARGE_413)
+    res.fail({
-        .json({ error: 'This file is too large. It exceeds the maximum file size authorized.' })
+      status: HttpStatusCode.PAYLOAD_TOO_LARGE_413,
+      message: 'This file is too large. It exceeds the maximum file size authorized.',
+      type: ServerErrorCode.MAX_FILE_SIZE_REACHED
+    })
    return false
  }
  if (await isAbleToUploadVideo(user.id, videoFileSize) === false) {
-    res.status(HttpStatusCode.PAYLOAD_TOO_LARGE_413)
+    res.fail({
-        .json({ error: 'The user video quota is exceeded with this video.' })
+      status: HttpStatusCode.PAYLOAD_TOO_LARGE_413,
+      message: 'The user video quota is exceeded with this video.',
+      type: ServerErrorCode.QUOTA_REACHED
+    })
    return false
  }
@@ -642,9 +591,10 @@ export async function isVideoAccepted (
  if (!acceptedResult || acceptedResult.accepted !== true) {
    logger.info('Refused local video.', { acceptedResult, acceptParameters })
-    res.status(HttpStatusCode.FORBIDDEN_403)
+    res.fail({
-       .json({ error: acceptedResult.errorMessage || 'Refused local video' })
+      status: HttpStatusCode.FORBIDDEN_403,
+      message: acceptedResult.errorMessage || 'Refused local video'
+    })
    return false
  }
diff --git a/server/middlewares/validators/webfinger.ts b/server/middlewares/validators/webfinger.ts
index a71422ed8..bcdd136c6 100644
--- a/server/middlewares/validators/webfinger.ts
+++ b/server/middlewares/validators/webfinger.ts
@@ -1,11 +1,11 @@
 import * as express from 'express'
 import { query } from 'express-validator'
+import { HttpStatusCode } from '../../../shared/core-utils/miscs/http-error-codes'
 import { isWebfingerLocalResourceValid } from '../../helpers/custom-validators/webfinger'
-import { logger } from '../../helpers/logger'
-import { ActorModel } from '../../models/activitypub/actor'
-import { areValidationErrors } from './utils'
 import { getHostWithPort } from '../../helpers/express-utils'
-import { HttpStatusCode } from '../../../shared/core-utils/miscs/http-error-codes'
+import { logger } from '../../helpers/logger'
+import { ActorModel } from '../../models/actor/actor'
+import { areValidationErrors } from './shared'
 const webfingerValidator = [
  query('resource').custom(isWebfingerLocalResourceValid).withMessage('Should have a valid webfinger resource'),
@@ -21,9 +21,10 @@ const webfingerValidator = [
    const actor = await ActorModel.loadLocalUrlByName(name)
    if (!actor) {
-      return res.status(HttpStatusCode.NOT_FOUND_404)
+      return res.fail({
-                .send({ error: 'Actor not found' })
+        status: HttpStatusCode.NOT_FOUND_404,
-                .end()
+        message: 'Actor not found'
+      })
    }
    res.locals.actorUrl = actor