Skip to main content

Documentation Index

Fetch the complete documentation index at: https://mintlify.com/Nettalco/dokploy/llms.txt

Use this file to discover all available pages before exploring further.

Templates let you deploy popular open-source tools in seconds without writing a single line of Docker Compose YAML. Each template is a pre-packaged blueprint that bundles a docker-compose.yml with a configuration file describing environment variables, domains, file mounts, and optional isolated networking — everything Dokploy needs to get the application running on your server straight away.

​
How Templates Work

When you deploy a template, Dokploy performs the following steps automatically:
  1. Fetches the template’s docker-compose.yml and template.toml configuration from https://templates.dokploy.com/blueprints/<id>/. A cached local copy is used as a fallback if the remote fetch fails.
  2. Generates dynamic values — random passwords, JWT secrets, a unique sslip.io domain based on your server IP, and an application name — using the processTemplate engine.
  3. Substitutes all ${variable} placeholders in the compose file and environment variable definitions with the generated (or user-provided) values.
  4. Creates a Docker Compose service in the selected project, pre-populated with the processed compose file, environment variables, and any required file mounts.
  5. Deploys the stack immediately using the same engine as any other Docker Compose service.
The template configuration (template.toml) drives all of this. It declares: 
[metadata]
id      = "plausible"
name    = "Plausible Analytics"
tags    = ["analytics", "privacy"]
version = "1.0.0"

[variables]
SECRET_KEY_BASE = "${password}"

[config]
isolated = true

[[config.domains]]
serviceName = "plausible"
port        = 8000

[config.env]
SECRET_KEY_BASE = "${SECRET_KEY_BASE}"
BASE_URL        = "https://${domain}"

​
Browsing Templates

compose.templates fetches the full template catalogue from https://templates.dokploy.com/meta.json and returns an array of template metadata objects. Each object contains:
FieldDescription
idUnique template identifier (used for fetching blueprint files).
nameHuman-readable template name.
descriptionShort description of the application.
tagsArray of category strings (e.g. ["analytics", "privacy"]).
versionTemplate version string.
logoURL to the application’s logo image.
links.githubURL to the application’s GitHub repository.
links.websiteOptional URL to the application’s website.
links.docsOptional URL to the application’s documentation.
compose.getTags derives a deduplicated list of all tags across the catalogue, which the dashboard uses to power the category filter: 
// Tags returned by compose.getTags (example)
["analytics", "cms", "database", "dev-tools", "productivity", "storage", "monitoring"]

​
Deploying a Template

1

Create a new Docker Compose service

Inside a project, click New Service → Docker Compose. In the compose creation dialog, switch to the Templates tab.
2

Select a template

Browse or filter the template library by category tag. Click on a template card to select it. The template description, logo, and links are shown in a preview panel.
3

Configure domain and environment variables

Dokploy pre-fills a randomly generated sslip.io domain and all required credentials (passwords, secrets, etc.). You can override any of these values before deploying — for example, replacing the generated domain with your own custom domain.
4

Select a server (if applicable)

On multi-server setups, choose the target server from the Server dropdown. The server’s IP address is used to generate the sslip.io domain.
5

Deploy

Click Deploy. Dokploy calls compose.deployTemplate, which processes the template, creates the compose service, and starts the deployment. You will be redirected to the service page where you can follow the deployment logs in real time.

​
Template Categories

The template library is organised by tags. Common categories include:
CategoryExample Applications
AnalyticsPlausible Analytics, Umami
CMSGhost, Directus, Strapi
DatabasesPostgreSQL, MySQL, MariaDB, Redis, MongoDB
Dev ToolsGitea, Plane, AppSmith
ProductivityCal.com, Nextcloud, Mattermost
Backend / BaaSPocketBase, Supabase, Appwrite
MonitoringGrafana, Uptime Kuma
StorageMinIO
Use compose.getTags to retrieve the live list of available tags, as new templates are added to the catalogue regularly.

​
How compose.processTemplate Works

compose.processTemplate is the engine behind template variable substitution. It accepts a base64-encoded payload containing a raw docker-compose.yml and a TOML configuration string, decodes them, and performs the following substitutions in the configuration’s env block:
PlaceholderSubstituted with
${domain}A randomly generated <project>-<hash>-<server-ip>.sslip.io hostname.
${password}A 16-character alphanumeric random password.
${hash}An 8-character random hex string.
${base64}A 32-byte base64-encoded random string.
${jwt}A signed HS256 JWT token.
${APP_NAME}The application’s internal name (derived from the project name and template ID).
Any named variableThe value of the corresponding entry in the template’s [variables] block.
The processed result includes:
  • envs — an array of KEY=value strings ready to be joined with newlines and written as the service’s .env file.
  • mounts — an array of { filePath, content } objects for config files that need to be written to the container’s filesystem.
  • domains — the list of domain/port/service mappings to register automatically.

​
Custom Templates

You can deploy your own template by pointing Dokploy to a Git repository that contains a docker-compose.yml and a template.toml at its root (or in a blueprints/<id>/ subdirectory matching the template CDN layout). Use a Docker Compose service with Git as the source type and set the source path to your repository. For one-click deployment of a custom template from an external URL, compose.deployTemplate accepts an optional baseUrl parameter. Set this to the base URL of your own template CDN (or a raw GitHub URL prefix) to override the default https://templates.dokploy.com. 
// Example: deploy from a custom template host
compose.deployTemplate({
  environmentId: "env_...",
  id: "my-custom-app",
  baseUrl: "https://my-template-cdn.example.com",
})

​
Updating a Template

Templates are fetched live from https://templates.dokploy.com at deploy time. To pick up upstream changes to a template (a new application version, updated environment variables, etc.), simply redeploy the service from the dashboard. Dokploy will fetch the latest docker-compose.yml and template.toml and regenerate the compose file.
Redeploying a template will regenerate dynamic values such as passwords. If the application stores data in a volume, the existing data is preserved — but if the regenerated password differs from the one currently in use by the running container, the application may fail to start. Back up your data and update the credentials in the running container before redeploying.

​
Isolated Deployments

Templates can declare isolated = true in their [config] block. When this flag is set, Dokploy places the compose stack in its own Docker network, preventing other services from reaching it directly. This is the default for most templates that bundle a database alongside the application. You can inspect whether a template uses isolated networking by checking the config.isolated field on the template metadata returned by compose.templates.
Dokploy generates strong random passwords for every template credential using a cryptographically secure random number generator. If you want to supply your own credentials, override the pre-filled values in the environment variable form before clicking Deploy. Use a password manager to generate and store credentials of at least 32 characters for database passwords and secret keys.

Build docs developers (and LLMs) love

Get started for freeTalk to us