3 <!-- START doctoc generated TOC please keep comment here to allow auto update -->
4 <!-- DON'T EDIT THIS SECTION, INSTEAD RE-RUN doctoc TO UPDATE -->
6 - [Concepts](#concepts)
8 - [Static files](#static-files)
10 - [Server API (only for plugins)](#server-api-only-for-plugins)
11 - [Settings](#settings)
13 - [Update video constants](#update-video-constants)
14 - [Add custom routes](#add-custom-routes)
15 - [Add external auth methods](#add-external-auth-methods)
16 - [Add new transcoding profiles](#add-new-transcoding-profiles)
17 - [Server helpers](#server-helpers)
18 - [Client API (themes & plugins)](#client-api-themes--plugins)
19 - [Plugin static route](#plugin-static-route)
20 - [Notifier](#notifier)
21 - [Markdown Renderer](#markdown-renderer)
22 - [Auth header](#auth-header)
23 - [Plugin router route](#plugin-router-route)
24 - [Custom Modal](#custom-modal)
25 - [Translate](#translate)
26 - [Get public settings](#get-public-settings)
27 - [Get server config](#get-server-config)
28 - [Add custom fields to video form](#add-custom-fields-to-video-form)
29 - [Register settings script](#register-settings-script)
30 - [Plugin selector on HTML elements](#plugin-selector-on-html-elements)
31 - [HTML placeholder elements](#html-placeholder-elements)
32 - [Add/remove left menu links](#addremove-left-menu-links)
33 - [Publishing](#publishing)
34 - [Write a plugin/theme](#write-a-plugintheme)
35 - [Clone the quickstart repository](#clone-the-quickstart-repository)
36 - [Configure your repository](#configure-your-repository)
37 - [Update README](#update-readme)
38 - [Update package.json](#update-packagejson)
39 - [Write code](#write-code)
40 - [Add translations](#add-translations)
41 - [Build your plugin](#build-your-plugin)
42 - [Test your plugin/theme](#test-your-plugintheme)
44 - [Unpublish](#unpublish)
45 - [Plugin & Theme hooks/helpers API](#plugin--theme-hookshelpers-api)
47 - [Compatibility with PeerTube](#compatibility-with-peertube)
48 - [Spam/moderation plugin](#spammoderation-plugin)
49 - [Other plugin examples](#other-plugin-examples)
51 <!-- END doctoc generated TOC please keep comment here to allow auto update -->
55 Themes are exactly the same as plugins, except that:
56 * Their name starts with `peertube-theme-` instead of `peertube-plugin-`
57 * They cannot declare server code (so they cannot register server hooks or settings)
58 * CSS files are loaded by client only if the theme is chosen by the administrator or the user
62 A plugin registers functions in JavaScript to execute when PeerTube (server and client) fires events. There are 3 types of hooks:
63 * `filter`: used to filter functions parameters or return values.
64 For example to replace words in video comments, or change the videos list behaviour
65 * `action`: used to do something after a certain trigger. For example to send a hook every time a video is published
66 * `static`: same than `action` but PeerTube waits their execution
68 On server side, these hooks are registered by the `library` file defined in `package.json`.
73 "library": "./main.js",
78 And `main.js` defines a `register` function:
83 async function register ({
100 unregisterExternalAuth,
101 registerIdAndPassAuth,
102 unregisterIdAndPassAuth
105 target: 'action:application.listening',
106 handler: () => displayHelloWorld()
111 Hooks prefixed by `action:api` also give access the original **express** [Request](http://expressjs.com/en/api.html#req) and [Response](http://expressjs.com/en/api.html#res):
114 async function register ({
116 peertubeHelpers: { logger }
119 target: 'action:api.video.updated',
120 handler: ({ req, res }) => logger.debug('original request parameters', { params: req.params })
126 On client side, these hooks are registered by the `clientScripts` files defined in `package.json`.
127 All client scripts have scopes so PeerTube client only loads scripts it needs:
134 "script": "client/common-client-plugin.js",
135 "scopes": [ "common" ]
138 "script": "client/video-watch-client-plugin.js",
139 "scopes": [ "video-watch" ]
146 And these scripts also define a `register` function:
149 function register ({ registerHook, peertubeHelpers }) {
151 target: 'action:application.init',
152 handler: () => onApplicationInit(peertubeHelpers)
159 Plugins can declare static directories that PeerTube will serve (images for example)
160 from `/plugins/{plugin-name}/{plugin-version}/static/`
161 or `/themes/{theme-name}/{theme-version}/static/` routes.
165 Plugins can declare CSS files that PeerTube will automatically inject in the client.
166 If you need to override existing style, you can use the `#custom-css` selector:
173 #custom-css .header {
174 background-color: red;
178 ### Server API (only for plugins)
182 Plugins can register settings, that PeerTube will inject in the administration interface.
183 The following fields will be automatically translated using the plugin translation files: `label`, `html`, `descriptionHTML`, `options.label`.
184 **These fields are injected in the plugin settings page as HTML, so pay attention to your translation files.**
189 function register (...) {
195 // type: 'input' | 'input-checkbox' | 'input-password' | 'input-textarea' | 'markdown-text' | 'markdown-enhanced' | 'select' | 'html'
197 // If type: 'select', give the select available options
199 { label: 'Label 1', value: 'value1' },
200 { label: 'Label 2', value: 'value2' }
203 // If type: 'html', set the HTML that will be injected in the page
204 html: '<strong class="...">Hello</strong><br /><br />'
207 descriptionHTML: 'The purpose of this field is...',
209 default: 'my super name',
211 // If the setting is not private, anyone can view its value (client code included)
212 // If the setting is private, only server-side hooks can access it
216 const adminName = await settingsManager.getSetting('admin-name')
218 const result = await settingsManager.getSettings([ 'admin-name', 'admin-password' ])
221 settingsManager.onSettingsChange(settings => {
222 settings['admin-name']
229 Plugins can store/load JSON data, that PeerTube will store in its database (so don't put files in there).
237 const value = await storageManager.getData('mykey')
238 await storageManager.storeData('mykey', { subkey: 'value' })
242 You can also store files in the plugin data directory (`/{plugins-directory}/data/{npm-plugin-name}`) **in PeerTube >= 3.2**.
243 This directory and its content won't be deleted when your plugin is uninstalled/upgraded.
250 const basePath = peertubeHelpers.plugin.getDataDirectoryPath()
252 fs.writeFile(path.join(basePath, 'filename.txt'), 'content of my file', function (err) {
258 #### Update video constants
260 You can add/delete video categories, licences or languages using the appropriate constant managers:
264 videoLanguageManager,
265 videoCategoryManager,
268 playlistPrivacyManager
270 videoLanguageManager.addConstant('al_bhed', 'Al Bhed')
271 videoLanguageManager.deleteConstant('fr')
273 videoCategoryManager.addConstant(42, 'Best category')
274 videoCategoryManager.deleteConstant(1) // Music
275 videoCategoryManager.resetConstants() // Reset to initial categories
276 videoCategoryManager.getConstants() // Retrieve all category constants
278 videoLicenceManager.addConstant(42, 'Best licence')
279 videoLicenceManager.deleteConstant(7) // Public domain
281 videoPrivacyManager.deleteConstant(2) // Remove Unlisted video privacy
282 playlistPrivacyManager.deleteConstant(3) // Remove Private video playlist privacy
286 #### Add custom routes
288 You can create custom routes using an [express Router](https://expressjs.com/en/4x/api.html#router) for your plugin:
294 const router = getRouter()
295 router.get('/ping', (req, res) => res.json({ message: 'pong' }))
297 // Users are automatically authenticated
298 router.get('/auth', async (res, res) => {
299 const user = await peertubeHelpers.user.getAuthUser(res)
301 const isAdmin = user.role === 0
302 const isModerator = user.role === 1
303 const isUser = user.role === 2
306 username: user.username,
315 The `ping` route can be accessed using:
316 * `/plugins/:pluginName/:pluginVersion/router/ping`
317 * Or `/plugins/:pluginName/router/ping`
320 #### Add external auth methods
322 If you want to add a classic username/email and password auth method (like [LDAP](https://framagit.org/framasoft/peertube/official-plugins/-/tree/master/peertube-plugin-auth-ldap) for example):
325 function register (...) {
327 registerIdAndPassAuth({
328 authName: 'my-auth-method',
330 // PeerTube will try all id and pass plugins in the weight DESC order
331 // Exposing this value in the plugin settings could be interesting
334 // Optional function called by PeerTube when the user clicked on the logout button
336 console.log('User %s logged out.', user.username')
339 // Optional function called by PeerTube when the access token or refresh token are generated/refreshed
340 hookTokenValidity: ({ token, type }) => {
341 if (type === 'access') return { valid: true }
342 if (type === 'refresh') return { valid: false }
345 // Used by PeerTube when the user tries to authenticate
346 login: ({ id, password }) => {
347 if (id === 'user' && password === 'super password') {
350 email: 'user@example.com'
352 displayName: 'User display name'
361 // Unregister this auth method
362 unregisterIdAndPassAuth('my-auth-method')
366 You can also add an external auth method (like [OpenID](https://framagit.org/framasoft/peertube/official-plugins/-/tree/master/peertube-plugin-auth-openid-connect), [SAML2](https://framagit.org/framasoft/peertube/official-plugins/-/tree/master/peertube-plugin-auth-saml2) etc):
369 function register (...) {
371 // result contains the userAuthenticated auth method you can call to authenticate a user
372 const result = registerExternalAuth({
373 authName: 'my-auth-method',
375 // Will be displayed in a button next to the login form
376 authDisplayName: () => 'Auth method'
378 // If the user click on the auth button, PeerTube will forward the request in this function
379 onAuthRequest: (req, res) => {
380 res.redirect('https://external-auth.example.com/auth')
383 // Same than registerIdAndPassAuth option
386 // Same than registerIdAndPassAuth option
387 // hookTokenValidity: ...
390 router.use('/external-auth-callback', (req, res) => {
391 // Forward the request to PeerTube
392 result.userAuthenticated({
396 email: 'user@example.com'
398 displayName: 'User display name'
402 // Unregister this external auth method
403 unregisterExternalAuth('my-auth-method)
407 #### Add new transcoding profiles
409 Adding transcoding profiles allow admins to change ffmpeg encoding parameters and/or encoders.
410 A transcoding profile has to be chosen by the admin of the instance using the admin configuration.
413 async function register ({
417 // Adapt bitrate when using libx264 encoder
419 const builder = (options) => {
420 const { input, resolution, fps, streamNum } = options
422 const streamString = streamNum ? ':' + streamNum : ''
424 // You can also return a promise
425 // All these options are optional
428 // Used to define an alternative scale filter, needed by some encoders
429 // Default to 'scale'
436 // Use a custom bitrate
437 '-b' + streamString + ' 10K'
442 const encoder = 'libx264'
443 const profileName = 'low-quality'
445 // Support this profile for VOD transcoding
446 transcodingManager.addVODProfile(encoder, profileName, builder)
448 // And/Or support this profile for live transcoding
449 transcodingManager.addLiveProfile(encoder, profileName, builder)
453 const builder = (options) => {
454 const { streamNum } = options
456 const streamString = streamNum ? ':' + streamNum : ''
458 // Always copy stream when PeerTube use libfdk_aac or aac encoders
464 const profileName = 'copy-audio'
466 for (const encoder of [ 'libfdk_aac', 'aac' ]) {
467 transcodingManager.addVODProfile(encoder, profileName, builder)
472 PeerTube will try different encoders depending on their priority.
473 If the encoder is not available in the current transcoding profile or in ffmpeg, it tries the next one.
474 Plugins can change the order of these encoders and add their custom encoders:
477 async function register ({
481 // Adapt bitrate when using libx264 encoder
483 const builder = () => {
490 // Support libopus and libvpx-vp9 encoders (these codecs could be incompatible with the player)
491 transcodingManager.addVODProfile('libopus', 'test-vod-profile', builder)
493 // Default priorities are ~100
494 // Lowest priority = 1
495 transcodingManager.addVODEncoderPriority('audio', 'libopus', 1000)
497 transcodingManager.addVODProfile('libvpx-vp9', 'test-vod-profile', builder)
498 transcodingManager.addVODEncoderPriority('video', 'libvpx-vp9', 1000)
500 transcodingManager.addLiveProfile('libopus', 'test-live-profile', builder)
501 transcodingManager.addLiveEncoderPriority('audio', 'libopus', 1000)
505 During live transcode input options are applied once for each target resolution.
506 Plugins are responsible for detecting such situation and applying input options only once if necessary.
510 PeerTube provides your plugin some helpers. For example:
513 async function register ({
518 const serverActor = await peertubeHelpers.server.getServerActor()
520 await peertubeHelpers.moderation.blockServer({ byAccountId: serverActor.Account.id, hostToBlock: '...' })
525 const video = await peertubeHelpers.videos.loadByUrl('...')
530 See the [plugin API reference](https://docs.joinpeertube.org/api-plugins) to see the complete helpers list.
532 ### Client API (themes & plugins)
534 #### Plugin static route
536 To get your plugin static route:
539 function register (...) {
540 const baseStaticUrl = peertubeHelpers.getBaseStaticRoute()
541 const imageUrl = baseStaticUrl + '/images/chocobo.png'
547 To notify the user with the PeerTube ToastModule:
550 function register (...) {
551 const { notifier } = peertubeHelpers
552 notifier.success('Success message content.')
553 notifier.error('Error message content.')
557 #### Markdown Renderer
559 To render a formatted markdown text to HTML:
562 function register (...) {
563 const { markdownRenderer } = peertubeHelpers
565 await markdownRenderer.textMarkdownToHTML('**My Bold Text**')
566 // return <strong>My Bold Text</strong>
568 await markdownRenderer.enhancedMarkdownToHTML('![alt-img](http://.../my-image.jpg)')
569 // return <img alt=alt-img src=http://.../my-image.jpg />
577 To make your own HTTP requests using the current authenticated user, use an helper to automatically set appropriate headers:
580 function register (...) {
582 target: 'action:auth-user.information-loaded',
583 handler: ({ user }) => {
585 // Useless because we have the same info in the ({ user }) parameter
586 // It's just an example
587 fetch('/api/v1/users/me', {
589 headers: peertubeHelpers.getAuthHeader()
590 }).then(res => res.json())
591 .then(data => console.log('Hi %s.', data.username))
597 #### Plugin router route
601 To get your plugin router route, you can use `peertubeHelpers.getBaseRouterRoute()`:
604 function register (...) {
606 target: 'action:video-watch.video.loaded',
607 handler: ({ video }) => {
608 fetch(peertubeHelpers.getBaseRouterRoute() + '/my/plugin/api', {
610 headers: peertubeHelpers.getAuthHeader()
611 }).then(res => res.json())
612 .then(data => console.log('Hi %s.', data))
620 To show a custom modal:
623 function register (...) {
624 peertubeHelpers.showModal({
625 title: 'My custom modal title',
626 content: '<p>My custom modal content</p>',
627 // Optionals parameters :
630 // show cancel button and call action() after hiding modal
631 cancel: { value: 'cancel', action: () => {} },
632 // show confirm button and call action() after hiding modal
633 confirm: { value: 'confirm', action: () => {} },
640 You can translate some strings of your plugin (PeerTube will use your `translations` object of your `package.json` file):
643 function register (...) {
644 peertubeHelpers.translate('User name')
645 .then(translation => console.log('Translated User name by ' + translation))
649 #### Get public settings
651 To get your public plugin settings:
654 function register (...) {
655 peertubeHelpers.getSettings()
657 if (!s || !s['site-id'] || !s['url']) {
658 console.error('Matomo settings are not set.')
667 #### Get server config
670 function register (...) {
671 peertubeHelpers.getServerConfig()
673 console.log('Fetched server config.', config)
678 #### Add custom fields to video form
680 To add custom fields in the video form (in *Plugin settings* tab):
683 async function register ({ registerVideoField, peertubeHelpers }) {
684 const descriptionHTML = await peertubeHelpers.translate(descriptionSource)
685 const commonOptions = {
686 name: 'my-field-name,
687 label: 'My added field',
688 descriptionHTML: 'Optional description',
690 // type: 'input' | 'input-checkbox' | 'input-password' | 'input-textarea' | 'markdown-text' | 'markdown-enhanced' | 'select' | 'html'
691 // /!\ 'input-checkbox' could send "false" and "true" strings instead of boolean
692 type: 'input-textarea',
695 // Optional, to hide a field depending on the current form state
696 // liveVideo is in the options object when the user is creating/updating a live
697 // videoToUpdate is in the options object when the user is updating a video
698 hidden: ({ formValues, videoToUpdate, liveVideo }) => {
699 return formValues.pluginData['other-field'] === 'toto'
703 for (const type of [ 'upload', 'import-url', 'import-torrent', 'update', 'go-live' ]) {
704 registerVideoField(commonOptions, { type })
709 PeerTube will send this field value in `body.pluginData['my-field-name']` and fetch it from `video.pluginData['my-field-name']`.
711 So for example, if you want to store an additional metadata for videos, register the following hooks in **server**:
714 async function register ({
718 const fieldName = 'my-field-name'
720 // Store data associated to this video
722 target: 'action:api.video.updated',
723 handler: ({ video, body }) => {
724 if (!body.pluginData) return
726 const value = body.pluginData[fieldName]
729 storageManager.storeData(fieldName + '-' + video.id, value)
733 // Add your custom value to the video, so the client autofill your field using the previously stored value
735 target: 'filter:api.video.get.result',
736 handler: async (video) => {
737 if (!video) return video
738 if (!video.pluginData) video.pluginData = {}
740 const result = await storageManager.getData(fieldName + '-' + video.id)
741 video.pluginData[fieldName] = result
749 #### Register settings script
751 To hide some fields in your settings plugin page depending on the form state:
754 async function register ({ registerSettingsScript }) {
755 registerSettingsScript({
756 isSettingHidden: options => {
757 if (options.setting.name === 'my-setting' && options.formValues['field45'] === '2') {
766 #### Plugin selector on HTML elements
768 PeerTube provides some selectors (using `id` HTML attribute) on important blocks so plugins can easily change their style.
770 For example `#plugin-selector-login-form` could be used to hide the login form.
772 See the complete list on https://docs.joinpeertube.org/api-plugins
774 #### HTML placeholder elements
776 PeerTube provides some HTML id so plugins can easily insert their own element:
779 async function register (...) {
780 const elem = document.createElement('div')
781 elem.className = 'hello-world-h4'
782 elem.innerHTML = '<h4>Hello everybody! This is an element next to the player</h4>'
784 document.getElementById('plugin-placeholder-player-next').appendChild(elem)
788 See the complete list on https://docs.joinpeertube.org/api-plugins
790 #### Add/remove left menu links
792 Left menu links can be filtered (add/remove a section or add/remove links) using the `filter:left-menu.links.create.result` client hook.
797 PeerTube plugins and themes should be published on [NPM](https://www.npmjs.com/) so that PeerTube indexes take into account your plugin (after ~ 1 day). An official plugin index is available on [packages.joinpeertube.org](https://packages.joinpeertube.org/api/v1/plugins), with no interface to present packages.
799 > The official plugin index source code is available at https://framagit.org/framasoft/peertube/plugin-index
801 ## Write a plugin/theme
804 * Find a name for your plugin or your theme (must not have spaces, it can only contain lowercase letters and `-`)
805 * Add the appropriate prefix:
806 * If you develop a plugin, add `peertube-plugin-` prefix to your plugin name (for example: `peertube-plugin-mysupername`)
807 * If you develop a theme, add `peertube-theme-` prefix to your theme name (for example: `peertube-theme-mysupertheme`)
808 * Clone the quickstart repository
809 * Configure your repository
811 * Update `package.json`
812 * Register hooks, add CSS and static files
813 * Test your plugin/theme with a local PeerTube installation
814 * Publish your plugin/theme on NPM
816 ### Clone the quickstart repository
818 If you develop a plugin, clone the `peertube-plugin-quickstart` repository:
821 $ git clone https://framagit.org/framasoft/peertube/peertube-plugin-quickstart.git peertube-plugin-mysupername
824 If you develop a theme, clone the `peertube-theme-quickstart` repository:
827 $ git clone https://framagit.org/framasoft/peertube/peertube-theme-quickstart.git peertube-theme-mysupername
830 ### Configure your repository
832 Set your repository URL:
835 $ cd peertube-plugin-mysupername # or cd peertube-theme-mysupername
836 $ git remote set-url origin https://your-git-repo
841 Update `README.md` file:
847 ### Update package.json
849 Update the `package.json` fields:
850 * `name` (should start with `peertube-plugin-` or `peertube-theme-`)
855 * `engine.peertube` (the PeerTube version compatibility, must be `>=x.y.z` and nothing else)
857 **Caution:** Don't update or remove other keys, or PeerTube will not be able to index/install your plugin.
858 If you don't need static directories, use an empty `object`:
868 And if you don't need CSS or client script files, use an empty `array`:
881 Now you can register hooks or settings, write CSS and add static directories to your plugin or your theme :)
883 **Caution:** It's up to you to check the code you write will be compatible with the PeerTube NodeJS version,
884 and will be supported by web browsers.
885 If you want to write modern JavaScript, please use a transpiler like [Babel](https://babeljs.io/).
886 If you want to use __Typescript__ see section below.
890 You can add __PeerTube__ types as dev dependencies:
892 npm install --save-dev @peertube/peertube-types
895 This package exposes *server* definition files by default:
897 import { RegisterServerOptions } from '@peertube/peertube-types/server/types'
899 export async function register ({ registerHook }: RegisterServerOptions) {
901 target: 'action:application.listening',
902 handler: () => displayHelloWorld()
907 But it also exposes client types and various models used in __PeerTube__:
909 import { RegisterClientOptions } from '@larriereguichet/peertube-types/client/types';
910 import { Video } from '@larriereguichet/peertube-types/shared';
912 function register({ registerHook, peertubeHelpers }: RegisterClientOptions) {
914 target: 'action:admin-plugin-settings.init',
915 handler: ({ npmName }: { npmName: string }) => {
916 if ('peertube-plugin-transcription' !== npmName) {
923 target: 'action:video-watch.video.loaded',
924 handler: ({ video }: { video: Video }) => {
925 fetch(`${peertubeHelpers.getBaseRouterRoute()}/videos/${video.uuid}/captions`, {
927 headers: peertubeHelpers.getAuthHeader(),
929 .then((res) => res.json())
930 .then((data) => console.log('Hi %s.', data));
937 > Other types are accessible from the shared path `@peertube/peertube-types/shared`.
941 If you want to translate strings of your plugin (like labels of your registered settings), create a file and add it to `package.json`:
947 "fr": "./languages/fr.json",
948 "pt-BR": "./languages/pt-BR.json"
954 The key should be one of the locales defined in [i18n.ts](https://github.com/Chocobozzz/PeerTube/blob/develop/shared/models/i18n/i18n.ts).
956 Translation files are just objects, with the english sentence as the key and the translation as the value.
957 `fr.json` could contain for example:
961 "Hello world": "Hello le monde"
965 ### Build your plugin
967 If you added client scripts, you'll need to build them using webpack.
975 Add/update your files in the `clientFiles` array of `webpack.config.js`:
978 $ $EDITOR ./webpack.config.js
981 Build your client files:
987 You built files are in the `dist/` directory. Check `package.json` to correctly point to them.
990 ### Test your plugin/theme
992 You'll need to have a local PeerTube instance:
993 * Follow the [dev prerequisites](https://github.com/Chocobozzz/PeerTube/blob/develop/.github/CONTRIBUTING.md#prerequisites)
994 (to clone the repository, install dependencies and prepare the database)
995 * Build PeerTube (`--light` to only build the english language):
998 $ npm run build -- --light
1007 * Run PeerTube (you can access to your instance on http://localhost:9000):
1010 $ NODE_ENV=test npm start
1013 * Register the instance via the CLI:
1016 $ node ./dist/server/tools/peertube.js auth add -u 'http://localhost:9000' -U 'root' --password 'test'
1019 Then, you can install or reinstall your local plugin/theme by running:
1022 $ node ./dist/server/tools/peertube.js plugins install --path /your/absolute/plugin-or-theme/path
1027 Go in your plugin/theme directory, and run:
1033 Every time you want to publish another version of your plugin/theme, just update the `version` key from the `package.json`
1034 and republish it on NPM. Remember that the PeerTube index will take into account your new plugin/theme version after ~24 hours.
1036 > If you need to force your plugin update on a specific __PeerTube__ instance, you may update the latest available version manually:
1038 > UPDATE "plugin" SET "latestVersion" = 'X.X.X' WHERE "plugin"."name" = 'plugin-shortname';
1040 > You'll then be able to click the __Update plugin__ button on the plugin list.
1044 If for a particular reason you don't want to maintain your plugin/theme anymore
1045 you can deprecate it. The plugin index will automatically remove it preventing users to find/install it from the PeerTube admin interface:
1048 $ npm deprecate peertube-plugin-xxx@"> 0.0.0" "explain here why you deprecate your plugin/theme"
1051 ## Plugin & Theme hooks/helpers API
1053 See the dedicated documentation: https://docs.joinpeertube.org/api-plugins
1058 ### Compatibility with PeerTube
1060 Unfortunately, we don't have enough resources to provide hook compatibility between minor releases of PeerTube (for example between `1.2.x` and `1.3.x`).
1062 * Don't make assumptions and check every parameter you want to use. For example:
1066 target: 'filter:api.video.get.result',
1068 // We check the parameter exists and the name field exists too, to avoid exceptions
1069 if (video && video.name) video.name += ' <3'
1075 * Don't try to require parent PeerTube modules, only use `peertubeHelpers`. If you need another helper or a specific hook, please [create an issue](https://github.com/Chocobozzz/PeerTube/issues/new/choose)
1076 * Don't use PeerTube dependencies. Use your own :)
1078 If your plugin is broken with a new PeerTube release, update your code and the `peertubeEngine` field of your `package.json` field.
1079 This way, older PeerTube versions will still use your old plugin, and new PeerTube versions will use your updated plugin.
1081 ### Spam/moderation plugin
1083 If you want to create an antispam/moderation plugin, you could use the following hooks:
1084 * `filter:api.video.upload.accept.result`: to accept or not local uploads
1085 * `filter:api.video-thread.create.accept.result`: to accept or not local thread
1086 * `filter:api.video-comment-reply.create.accept.result`: to accept or not local replies
1087 * `filter:api.video-threads.list.result`: to change/hide the text of threads
1088 * `filter:api.video-thread-comments.list.result`: to change/hide the text of replies
1089 * `filter:video.auto-blacklist.result`: to automatically blacklist local or remote videos
1091 ### Other plugin examples
1093 You can take a look to "official" PeerTube plugins if you want to take inspiration from them: https://framagit.org/framasoft/peertube/official-plugins