Menu
Products
Products
Video Hosting
Upload and manage your videos in a centralized video library.
Image Hosting
Upload and manage all your images in a centralized library.
Galleries
Choose from 100+templates to showcase your media in style.
Video Messaging
Record, and send personalized video messages.
CincoTube
Create your own community video hub your team, students or fans.
Pages
Create dedicated webpages to share your videos and images.
Live
Create dedicated webpages to share your videos and images.
For Developers
Video API
Build a unique video experience.
DeepUploader
Collect and store user content from anywhere with our file uploader.
Solutions
Solutions
Enterprise
Supercharge your business with secure, internal communication.
Townhall
Webinars
Team Collaboration
Learning & Development
Creative Professionals
Get creative with a built in-suite of editing and marketing tools.
eCommerce
Boost sales with interactive video and easy-embedding.
Townhall
Webinars
Team Collaboration
Learning & Development
eLearning & Training
Host and share course materials in a centralized portal.
Sales & Marketing
Attract, engage and convert with interactive tools and analytics.
"Cincopa helped my Enterprise organization collaborate better through video."
Book a Demo
Resources
Resources
Blog
Learn about the latest industry trends, tips & tricks.
Help Centre
Get access to help articles FAQs, and all things Cincopa.
Partners
Check out our valued list of partners.
Product Updates
Stay up-to-date with our latest greatest features.
Ebooks, Guides & More
Customer Stories
Hear how we've helped businesses succeed.
Boost Campaign Performance Through Video
Discover how to boost your next campaign by using video.
Download Now
Pricing
Watch a Demo
Demo
Login
Start Free Trial
Managing video assets in Strapi demands careful planning because large files can strain storage, slow API responses, and create inconsistent data across content types. Without clear structures, uploads become unreliable, metadata goes missing, and access control weakens and causes broken references, playback issues, and security gaps. Applying best practices to the Strapi Media Library ensures predictable data models, efficient storage, reliable delivery, and maintainable video workflows at scale. Structuring the Strapi Media Library for Video Organizing videos helps create a predictable data model. If you attach video files as raw media fields across multiple content types, you end up with inconsistent metadata and fragmented references. Instead, define explicit metadata fields and capture them in one reusable structure. This ensures uniformity, avoids duplication, and enables automation. For example, a video-asset content type can hold the video file reference plus metadata like duration, resolution, codec, bitrate, and a poster image. Creating this as a centralized content type ensures that every piece of query logic interacts with a single, consistent shape instead of scattered media fields. { 'collectionName': 'video_assets', 'info': { 'singularName': 'video-asset', 'pluralName': 'video-assets', 'displayName': 'Video Asset' }, 'attributes': { 'file': { 'type': 'media', 'multiple': false, 'required': true }, 'duration': { 'type': 'integer' }, 'resolution': { 'type': 'string' }, 'codec': { 'type': 'string' }, 'bitrate': { 'type': 'integer' }, 'poster': { 'type': 'media', 'multiple': false } } } This design separates video ownership from consuming content types like articles or products. Instead of embedding videos directly, other content types reference video-asset entries. This makes queries cleaner and allows lifecycle automation on a single entity, which is especially useful for large-scale projects. Handling Video File Uploads Strapi’s default upload settings are not designed for large videos. If upload limits are left unchanged, files may fail or cause unnecessary strain on the server. Increasing size limits and applying validation ensure the system only accepts files that meet project expectations. In ./config/middlewares.js : module.exports = [ 'strapi::errors', { name: 'strapi::body', config: { formLimit: '200mb', // larger than default jsonLimit: '200mb', textLimit: '200mb' }, }, ]; For long-term scalability, local disk storage should be avoided. Providers like AWS S3, Google Cloud Storage, or Cloudinary offload heavy video traffic, provide resumable uploads, and integrate with CDNs. This separation ensures Strapi handles only metadata and references while storage providers handle delivery. Example Provider Config (./config/plugins.js) for AWS S3 : module.exports = ({ env }) => ({ upload: { config: { provider: 'aws-s3', providerOptions: { accessKeyId: env('AWS_ACCESS_KEY_ID'), secretAccessKey: env('AWS_ACCESS_SECRET'), region: env('AWS_REGION'), params: { Bucket: env('AWS_BUCKET') }, }, }, }, }); By configuring Strapi this way, uploads go directly to S3, ensuring large files don’t overwhelm the Strapi server. Managing Video Metadata Metadata is not optional. Frontends depend on duration, resolution, codec, and file size to decide whether to show a video inline, stream it, or block unsupported formats. Capturing metadata automatically prevents human error and guarantees consistency. You can hook into Strapi lifecycles to extract metadata immediately after upload. Using ffprobe from FFmpeg is a common pattern. ./api/video-asset/content-types/video-asset/lifecycles.js : const { execSync } = require('child_process'); module.exports = { async afterCreate(event) { const { result } = event; const filePath = result.file.url; // adjust per provider try { const probe = execSync(`ffprobe -v quiet -print_format json -show_format -show_streams ${filePath}`); const data = JSON.parse(probe.toString()); // Simplified example: extract duration & resolution const duration = Math.round(data.format.duration); const videoStream = data.streams.find(s => s.codec_type === 'video'); const resolution = `${videoStream.width}x${videoStream.height}`; await strapi.db.query('api::video-asset.video-asset').update({ where: { id: result.id }, data: { duration, resolution } }); } catch (e) { strapi.log.error('Metadata extraction failed', e); } }, }; Poster images should also be generated automatically, as they provide essential previews without loading the video file. Using FFmpeg during upload ensures posters remain in sync whenever the file changes. Security and Access Control for Video in Strapi Videos often include premium or sensitive content, so access management cannot be an afterthought. Strapi’s role-based access control ensures only authorized users can manage or view restricted videos. Without it, accidental leaks can break licensing agreements or expose internal content. For stronger protection, external providers like AWS CloudFront or Cloudinary support signed URLs. A signed URL provides time-limited access, preventing files from being shared indefinitely. This ensures that distribution remains under full control while still serving content efficiently. Example : Generating a signed URL with AWS SDK const AWS = require('aws-sdk'); const s3 = new AWS.S3(); function generateSignedUrl(key) { return s3.getSignedUrl('getObject', { Bucket: process.env.AWS_BUCKET, Key: key, Expires: 3600 // 1 hour }); } Finally, strict upload validation rules prevent oversized or unsupported files from entering the system. This protects both storage costs and playback reliability. Versioning and Updating Video Assets Replacing video files without breaking references is critical. If every new file creates a new record, content relationships break, which leads to missing videos in production. A better pattern is to keep the same video-asset entry and replace only the file reference while maintaining the record ID. To track changes, include a version field on the content type and increment it whenever the video file is replaced. Downstream systems, like CDNs or player clients, can use that field to invalidate caches or refresh video sources. await strapi.db.query('api::video-asset.video-asset').update({ where: { id: videoId }, data: { file: newFileId, version: { increment: 1 } } }); Over time, unused videos accumulate and waste storage space. Running cleanup jobs ensures that unreferenced assets do not remain indefinitely. A scheduled cron job can scan for assets with no relations and safely delete them, reducing costs while keeping the library maintainable. Storage Options for Video in Strapi Local storage is fine for development, but not for production. It lacks durability and scalability. Cloud storage services like AWS S3, Google Cloud Storage, or Azure Blob are designed for heavy media workloads, providing redundancy and seamless integration with CDNs. For large video assets, best practices include using multipart uploads and resumable transfers. This makes uploads more reliable by splitting a single upload into chunks, so a failed transfer doesn’t require starting from scratch. When videos are of a large size, connecting the upload process to transcoding pipelines also helps generate different playback formats. A final and essential step is using a CDN for delivery. Without a CDN, users far from the storage region may face buffering and latency issues. Setting up CDN-backed delivery ensures videos are cached at edge locations globally, while Strapi maintains metadata and access logic. This separation between metadata handling and storage-backed delivery is key to managing video at scale.
Video Hosting
Image Hosting
Galleries
Video Messaging
CincoTube
Pages
Live
