# Temps vs Dokploy

> Dokploy and Temps are both free self-hosted PaaS platforms with git-push and Docker Compose deploys. Dokploy (Apache 2.0 base with proprietary-licensed directories) uses Docker Swarm and Traefik and shows resource monitoring; its cloud is $4.50 per server, with SAML SSO on Enterprise. Temps (MIT / Apache 2.0) is one Rust binary with its proxy built in, running beside Docker, and includes error tracking, session replay, web analytics and uptime monitoring.

Last updated 2026-11-03 · Competitor prices checked October 2026

Canonical: https://temps.sh/compare/vs-dokploy

Self-hosting with the observability built in

## Short answer

What they share: Both are free, self-hosted PaaS platforms with git-push deploys, Docker Compose support, automatic SSL, managed databases and multi-server support. Where they diverge: Dokploy shows CPU, memory, disk and network usage per resource, but leaves error tracking, session replay, web analytics and uptime checks to other tools: about $211/month as Plausible, Sentry Team and LogRocket, or more services to run. Temps includes all four in the binary. What Dokploy has that Temps doesn't: Docker Swarm for multi-server clusters, a larger community (about 37,700 GitHub stars), a managed cloud you can use today from $4.50 per server, and SAML SSO on its Enterprise tier. Temps joins worker nodes to its own control plane for multi-node and puts SAML SSO in Premium.

## TL;DR

| Dimension | Temps | Dokploy | Better fit |
| --- | --- | --- | --- |
| Built-in observability | Analytics, errors, replay, uptime | Resource monitoring only | Temps |
| Cost with full observability | $0 (included) | $0 + services to run, or ~$211/mo of SaaS | Temps |
| Multi-server clustering | Worker nodes on one control plane | Docker Swarm | Dokploy |
| Community size | Younger, smaller | About 37,700 GitHub stars | Dokploy |
| Licence | MIT / Apache 2.0 | Apache 2.0 except its /proprietary enterprise features | Tie |

## Key differences

- **Application observability built in:** Dokploy monitors CPU, memory, storage and network for each resource. Error tracking, session replay, web analytics and uptime checks come from separate tools such as Sentry, a replay product and Uptime Kuma. Temps includes all four.
- **Proxy built into the binary:** Temps is one Rust binary with its Pingora-based proxy built in (no Traefik), running beside Docker and a TimescaleDB container that the installer sets up. Dokploy is a Node.js application that runs with Docker, Traefik and several containers.
- **Sentry-compatible error tracking:** Keep the official Sentry SDK and change the DSN to point at Temps. Dokploy has no error aggregation of its own.
- **Session replay built in:** Watch real user sessions to debug UX issues, recorded with rrweb and stored on your own server. With Dokploy, replay is a separate tool such as OpenReplay or a SaaS product.

## Features

| Feature | Temps | Dokploy |
| --- | --- | --- |
| Git push deployments | Yes | Yes |
| Docker support | Yes | Yes |
| Docker Compose support | Yes | Yes (Also offers Docker Swarm mode) |
| Automatic SSL | Yes | Yes |
| Custom domains | Yes | Yes |
| Preview deployments | Yes | Yes |
| Managed PostgreSQL | Yes | Yes |
| Managed Redis | Yes | Yes |
| Managed MongoDB | Yes | Yes |
| S3-compatible storage | Yes (Built-in (RustFS; legacy MinIO supported)) | No |
| Error tracking | Yes (Sentry-compatible) | No (External tool required) |
| Web analytics | Yes (First-party, events and funnels) | No (External tool required) |
| Session replay | Yes (rrweb-based) | No |
| Uptime monitoring | Yes (Built-in checks + alerting) | No (External tool (e.g. Uptime Kuma)) |
| Server and container metrics | Yes | Yes (CPU, memory, storage and network per resource) |
| Transactional email | Yes (Through SES, Scaleway or an SMTP relay) | No |
| Multi-server cluster | Yes (Worker nodes over your private network) | Yes (Docker Swarm) |
| Team roles | Yes (Owner, Admin, Deployer, Viewer) | Yes (Basic RBAC on Startup; fine-grained on Enterprise) |
| SSO | Yes (OIDC free; SAML on Premium) | Yes (SAML on Enterprise) |
| Licence | MIT / Apache 2.0 | Apache 2.0 base (Code in /proprietary directories is under a proprietary licence) |

## Pricing

| Item | Temps | Dokploy |
| --- | --- | --- |
| Self-hosted | $0 | $0 |
| Managed option | Temps Cloud: $29/mo, invite-only beta | From $4.50/mo per server |
| With full observability | $0 (included) | $0 + services to run, or ~$211/mo of SaaS |
| SAML SSO | Premium $399/org/mo (self-hosted) | Enterprise (custom quote) |

Both are free to self-host. Dokploy's cloud is $4.50/month per server, or from $15/month for three servers with team features, and SAML SSO is on its custom-priced Enterprise tier. For application observability you either run Sentry or GlitchTip, a replay tool and Uptime Kuma yourself, or pay for SaaS: Plausible, Sentry Team and LogRocket come to about $211/month. Temps includes the equivalent in one binary; OIDC sign-in is free and SAML SSO is part of Premium ($399 per organisation per month).

### Dokploy plans

| Plan | Price | Servers | Team and security |
| --- | --- | --- | --- |
| Self-hosted | $0 | Unlimited | Open source edition |
| Hobby (cloud) | $4.50/mo per server | Pay per server | No team roles or 2FA |
| Startup (cloud) | From $15/mo | 3 included, then $4.50 each | Unlimited users, basic RBAC, 2FA |
| Enterprise | Custom | Custom | SAML SSO, SCIM, audit logs, fine-grained RBAC |

## Choose Temps if

- You want error tracking, session replay, analytics and uptime checks without extra tools
- You want one binary with the proxy built in rather than Traefik plus several containers
- You need session replay to debug user-facing issues
- You want transactional email in the platform
- You want OIDC sign-in without an enterprise tier

## Choose Dokploy if

- You want Docker Swarm for multi-server, multi-container clusters
- You already have an observability stack you prefer
- You want a managed cloud you can buy today
- You prefer Dokploy's larger community (about 37,700 GitHub stars)

## Migrating from Dokploy (easy)

Temps has a Dokploy import wizard: connect it to your Dokploy instance's API, and it discovers the applications and databases, shows you a plan, and recreates each one as a Temps project with its environment variables and a live deployment. Compose-based apps deploy through the Docker Compose preset; splitting a Compose stack into separate Temps services is optional.

[Step-by-step: migrate from Dokploy with the import wizard](https://temps.sh/docs/from-dokploy)

## FAQ

### Dokploy vs Temps: which should I choose?

Choose Temps if you want deployments plus application observability: web analytics, Sentry-compatible error tracking, session replay and uptime monitoring in one Rust binary. Choose Dokploy if Docker Swarm clusters matter to you, you want its larger community (about 37,700 GitHub stars), or you want a managed cloud now. Both are free to self-host and deploy Docker Compose stacks, with git-push deploys, automatic SSL, preview environments and managed PostgreSQL, Redis and MongoDB.

### What does Temps include that Dokploy doesn't?

Dokploy monitors CPU, memory, storage and network per resource. Temps adds web analytics, error tracking (point the official Sentry SDK at a Temps DSN), session replay and uptime monitoring with alerting, plus S3-compatible object storage and transactional email. With Dokploy those come from separate tools such as Sentry or GlitchTip, OpenReplay and Uptime Kuma.

### What does Dokploy do better than Temps?

Dokploy has Docker Swarm for multi-server clusters, a larger community, a managed cloud from $4.50 per server, and SAML SSO, SCIM and audit logs on its Enterprise tier. Temps joins worker nodes to its own control plane rather than Swarm, and its SAML SSO and SCIM are part of Premium.

### Is Dokploy open source?

Mostly. Dokploy's licence file puts the code under Apache 2.0, except for directories named /proprietary, which are under a proprietary licence; GitHub reports the licence as 'Other'. Temps is dual-licensed MIT / Apache 2.0.

### How much does each cost?

Both are free to self-host. Dokploy's cloud is $4.50/month per server, or from $15/month for three servers with team features, and Enterprise is custom. Temps Cloud, a hosted control plane for your own servers, is $29/month in an invite-only beta; Premium for self-hosted Temps is $399 per organisation per month. The larger difference is observability: with Dokploy you pay for, or run, separate error tracking, replay, analytics and uptime tools.

### Can I migrate from Dokploy to Temps automatically?

Yes. The Temps import wizard connects to your Dokploy instance's API, discovers applications and databases, and recreates them as Temps projects with environment variables and a live deployment. The Dokploy migration guide walks through each step.

## Sources

- [Dokploy pricing](https://dokploy.com/pricing)
- [Dokploy on GitHub](https://github.com/Dokploy/dokploy)
- [Sentry pricing](https://sentry.io/pricing/)

## Further reading

- [Migrate from Dokploy With the Import Wizard](https://temps.sh/docs/from-dokploy): Connect Temps to your Dokploy API, review the discovered apps and databases, and recreate them as Temps projects.
- [Temps vs Coolify](https://temps.sh/compare/vs-coolify): The other large self-hosted PaaS, compared on observability, templates and pricing.
- [Dokploy Alternatives 2026](https://temps.sh/blog/dokploy-alternatives-2026): Temps, Coolify, CapRover, Dokku, Kamal and Easypanel compared on licence, pricing, multi-server and observability.
- [5 Best Coolify Alternatives for Self-Hosted PaaS](https://temps.sh/blog/5-best-coolify-alternatives-self-hosted-paas-2026): Dokploy, Temps, CapRover and Dokku compared on features and pricing.
- [Error tracking with a Sentry-compatible DSN](https://temps.sh/docs/error-tracking): Point your existing Sentry SDK at Temps and keep stack traces on your own server.

---

Source: https://temps.sh/compare/vs-dokploy · Index of all pages: https://temps.sh/llms.txt