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
Since Netlify focuses on static site hosting and serverless functions, it doesn’t support hosting Node.js servers in the traditional way. To deploy Strapi on Netlify, you can split the setup into 2 parts: Hosting the Strapi API on a backend service and serving the static Strapi admin panel from Netlify. Packaging Strapi into Netlify Functions for a serverless approach. This workflow uses Netlify’s strength in serving static assets and an external backend service or functions layer to handle Strapi’s Node.js runtime. Prerequisites Before deploying, make sure you have: Node.js with npm or Yarn: Required to run Strapi and manage project dependencies. Strapi project set up locally: Ensures you have a working Strapi instance before deployment. Git repository initialized: Needed for version control and pushing your code to deployment platforms. Netlify CLI installed and logged in: Required to connect your local Strapi project with Netlify for deployment. Production database access (PostgreSQL, MySQL, or MongoDB): Essential for storing data in a live environment, since SQLite (default) isn’t suitable for production. Part 1: Hosting Strapi API on a Backend Service + Admin Panel on Netlify Preparing Strapi for Deployment Strapi defaults to development mode, which is not secure for production. Configure your project to run safely in a production environment. Create a .env.production File: A .env.production file centralizes sensitive values (like database credentials, JWT secrets, and app keys) making your production environment secure, consistent, and easy to manage without hardcoding secrets. This keeps secrets secure and consistent without hardcoding them. # .env.production HOST=0.0.0.0 PORT=1337 APP_KEYS=your_app_keys_here API_TOKEN_SALT=your_api_token_salt_here ADMIN_JWT_SECRET=your_admin_jwt_secret_here DATABASE_CLIENT=postgres DATABASE_HOST=your-db-host.com DATABASE_PORT=5432 DATABASE_NAME=strapi_prod DATABASE_USERNAME=db_user DATABASE_PASSWORD=db_password Explanation: APP_KEYS=your_app_keys_here : Used for session and cookie signing. API_TOKEN_SALT=your_api_token_salt_here : Salt for generating API tokens. Update package.json File In your Strapi project, update the package.json file to include production-ready scripts so your host can build and run Strapi correctly: { 'scripts': { 'develop': 'strapi develop', 'build': 'strapi build', 'start': 'strapi start' } } Explanation : ssl : env.bool('DATABASE_SSL', false) : Enables SSL if true (default : false). Deploying Backend API The Strapi API cannot run directly on Netlify, since it requires a persistent Node.js runtime. You have two options: Deploy on a Node.js Host Use a service like Render, Heroku, or Railway. Step 1 : Push your repository to GitHub. Step 2 : Connect the repository to your hosting service. Step 3 : Configure environment variables from .env.production. Step 4 : Deploy it using: npm run build npm run start This creates a reliable and production-ready API . Hosting the Strapi Admin Panel on Netlify The Strapi Admin Panel is a React Single Page Application. Once built, it becomes static files that Netlify can serve globally for faster load times and seamless Git-based deployment. Build the Admin Panel Before Netlify can host the admin panel, Strapi needs to compile the React source into production-ready static files. Running the build command bundles JavaScript, CSS, and assets into the ./build/admin directory so they can be served independently of the backend API. npm run build → Output is generated in ./build/admin. Configure netlify.toml Netlify needs explicit instructions on where to find the static files and how to build them. The netlify.toml file tells Netlify to run the Strapi build process and publish the compiled admin panel folder, so that deployments work the same way every time. [build] publish = 'build/admin' command = 'npm run build' Deploy Once the files are built and configuration is set, deployment pushes your admin panel to Netlify’s CDN. From there, you can either trigger a manual deploy or connect your GitHub repository for automatic builds and updates whenever you push changes. netlify deploy --prod Or connect your GitHub repo to Netlify for auto-build and deployment. Connecting Admin Panel to Backend API By default, the Strapi Admin Panel doesn’t know where your backend API lives. Since the panel will run from Netlify’s domain and the API from another host, you must explicitly configure the production server settings. This ensures that all admin actions (login, content management, API calls) point to the correct backend service. Configure API URL in config/env/production/server.js The server.js config file tells Strapi where it should run in production and which backend URL the Admin Panel should connect to. Without this setting, your admin interface won’t be able to authenticate or fetch content from the deployed backend. module.exports = ({ env }) => ({ host: env('HOST', '0.0.0.0'), port: env.int('PORT', 1337), url: env('STRAPI_ADMIN_URL', 'https://your-backend-service.com'), }); Explanation : module.exports = ({ env }) => ({ ... }) : Exports a function that reads environment variables and sets Strapi server configuration. host: env('HOST', '0.0.0.0') : Defines the host where Strapi runs. Defaults to 0.0.0.0 (accessible from all network interfaces). port: env.int('PORT', 1337) : Sets the server port. If not defined in environment variables, it defaults to 1337 . Enable CORS in config/middlewares.js Since the Admin Panel (hosted on Netlify) and the API (hosted elsewhere) are on different domains, browsers will block requests unless you configure Cross-Origin Resource Sharing (CORS). Enabling CORS here allows trusted origins (your Netlify site) to access the backend securely. module.exports = [ 'strapi::errors', 'strapi::security', { name: 'strapi::cors', config: { enabled: true, origin: ['https://your-netlify-site.netlify.app'], }, }, 'strapi::logger', 'strapi::query', 'strapi::body', 'strapi::session', 'strapi::favicon', 'strapi::public', ]; Restart the backend for changes to take effect. Post-Deployment Configuration Once your Strapi backend and admin panel are live, align your deployment environment with the same settings you used locally. Without proper environment variables and domain setup, the admin panel may fail to authenticate, connect to the database, or run in production mode. Adding these values in Netlify runs your build securely and consistently, just like in your .env.production file. Add environment variables in Netlify, such as STRAPI_ADMIN_JWT_SECRET, NODE_ENV=production, and Database credentials (if used during admin build). (Optional) Configure a custom domain in Netlify and point DNS records to it. Testing the Deployment Deployment will complete after you verify that everything works end to end. Testing ensures that your Netlify-hosted Admin Panel can talk to the backend API, content is saved in the production database, and API routes return the expected data. Step 1 : Open your Netlify-hosted Admin Panel → log in. Step 2 : Create a content type, add entries → confirm they persist in your production database. Step 3 : Test API endpoints: curl https://your-backend-service.com/api/articles Expected : JSON response with your content. Part 2: Packaging Strapi into Netlify Functions (Experimental) Deploy API via Netlify Functions (Experimental) You can package Strapi inside Netlify Functions, but this is not production-ready since serverless environments introduce cold starts, slower performance, and limited features. It’s best suited for quick demos or testing. Step 1 : Create netlify/functions/strapi.js const strapi = require('@strapi/strapi'); let app; exports.handler = async (event, context) => { if (!app) { app = await strapi().load(); } return app.server.app.callback()(event, context); }; Step 2 : Update netlify.toml [build] functions = 'netlify/functions' command = 'npm run build' Step 3 : Deploy with: netlify deploy --prod Note: This approach is experimental, limited, and best used only for demos or testing.
Video Hosting
Image Hosting
Galleries
Video Messaging
CincoTube
Pages
Live
