TeamCity pricing in 2026
./teamcity --professional --enterprise --cloud
TeamCity is JetBrains's CI/CD platform and the default CI choice for many JVM-heavy organisations. The pricing model is unusual for modern CI: TeamCity Professional is free with a generous-for-small-teams 3 build agents and 100 build configurations, and Enterprise pricing is a one-time-per-year licence fee rather than a per-user subscription. TeamCity Cloud (SaaS) is more conventional, billed per active user with included build credits. This page works through what each option costs in 2026 and where TeamCity fits in the CI/CD landscape.
Pricing here is sourced from the public TeamCity buy page and JetBrains licensing docs, re-verified July 2026 (Cloud $45/mo for 3 committers then $15 each additional, 8,000 build credits per committer; Server $2,399/yr base plus $359/agent after the 2025 list-price increase). Check the live page before committing, as JetBrains adjusts licence tiers periodically.
How much does TeamCity cost in 2026?
TeamCity Professional is free forever with 3 build agents and 100 build configurations, commercial use included. To lift the configuration limit, the self-hosted Server (Enterprise) licence is $2,399 per year with 3 agents included, plus $359 per additional build agent per year, and unlimited users at no per-seat cost. TeamCity Cloud, the JetBrains-hosted option, starts at $45 per month for the first 3 committers (24,000 build credits) and $15 for each additional committer, with 8,000 build credits per committer. Licences bought on or after 3 November 2025 renew at full list price, not the old 50% renewal rate.
The three flavours of TeamCity
| Edition | Cost | Build agents | Build configs |
|---|---|---|---|
| Professional | $0 | 3 included | 100 max |
| Server (Enterprise) | $2,399 / yr base | 3 included, +$359/agent/yr | Unlimited |
| Cloud (SaaS) | $45/mo for 3, +$15/user | Hosted by JetBrains | Unlimited |
# Server edition users get unlimited users at no per-seat cost; only build agents and the base server licence cost money.
What the free Professional tier actually covers
TeamCity Professional is free for any usage, commercial or otherwise. The limits are 3 build agents (so 3 concurrent jobs) and 100 build configurations (so 100 distinct pipelines). For a small team that means roughly 30-60 builds per day comfortably, depending on average build duration. The build-config limit catches larger teams faster than the agent limit: each branch-aware pipeline tends to count as a config, so a team with 25 microservices and a release pipeline per service hits the 100 cap quickly.
Beyond the limits, you upgrade to Server (also called Enterprise in some JetBrains documents). The Server upgrade removes the configuration limit and adds priority support, custom plugins and additional plugins-marketplace access. The base Server licence is $2,399 per year for the unlimited-configurations server with three agents, plus $359 per additional build agent per year. The cumulative price is much lower than per-user SaaS at scale: a JVM shop running 10 build agents pays $2,399 + 7 x $359 = $4,912 annually total, regardless of seat count.
Open-source projects get free Server licences via JetBrains's open-source programme. The application process is straightforward and the licence is comparable to JetBrains's IDE OSS programme.
TeamCity Cloud, in detail
TeamCity Cloud is the SaaS variant, hosted by JetBrains. Pricing starts at $45 per month for the first 3 committers, then $15 for each additional committer; every committer slot includes 8,000 build credits (plus 40 GB storage and 200 GB data transfer). Past the three-seat base this works out to a flat $15 per committer per month. A build credit is roughly equivalent to one minute on a standard Linux runner. The credit model is similar to CircleCI's approach: bigger machines (4-core, 8-core) consume more credits per minute, smaller machines fewer. Included subscription credits expire at the end of each month and are replenished; only on-demand credits bought separately (in blocks of 25,000) roll over.
For a 10-developer JVM team that runs 100 builds per day at 8 minutes each, monthly usage is 800 daily minutes times 21 working days = 16,800 minutes. That fits comfortably inside the 80,000 included credits (10 committers x 8,000) at the standard machine size. Total monthly cost = $45 for the first three committers plus 7 x $15 = $150. Compared to GitHub Actions Team for the same workload, TeamCity Cloud is very competitive at this scale, and the generous per-committer credit allowance keeps it cheap as build volume climbs, until heavy usage forces on-demand credit packs.
Cloud handles the operational responsibility for the server and the build agents. You write pipelines (in YAML or in the Kotlin DSL that TeamCity has historically championed) and TeamCity executes them. The trade-off vs Server is the per-user pricing model. Cloud works out to about $15 per committer per month past the three-seat base, so an 8-agent Server licence ($4,194 per year) only undercuts Cloud once committer count climbs past the low 20s, and sooner if heavy build volume pushes you into on-demand credit packs.
JVM-shop economics
TeamCity is over-represented in JVM shops for two reasons. First, JetBrains is the dominant JVM tooling vendor and the IntelliJ-TeamCity integration is genuinely tight: build configurations can be opened directly in IntelliJ, pipeline-level annotations show up in the IDE, and the developer workflow feels uniform across IDE and CI. Second, TeamCity's first-class support for Gradle and Maven, including detailed dependency analysis and parallel build distribution, is a noticeable productivity benefit for Gradle-heavy codebases.
For a 50-developer Java or Kotlin shop already paying for IntelliJ IDEA Ultimate licences, the marginal cost of TeamCity Server is small compared to the integration benefit. The same shop trying to adopt GitHub Actions or GitLab CI runs into Gradle cache warmth issues and slower JVM warmup penalties because the platforms are designed around stateless ephemeral runners rather than the persistent agent model TeamCity uses by default.
Outside JVM, the case for TeamCity is weaker. It supports Node, Python, Go and .NET adequately but the ecosystem advantage that matters in JVM (deep Gradle integration, JetBrains tooling parity) does not transfer. A Node-only team picking CI/CD on greenfield in 2026 would land on GitHub Actions or GitLab CI almost always; the JetBrains gravity that pulls JVM shops to TeamCity is absent.
Operational footprint
A self-hosted TeamCity Server runs comfortably on a single VM with 4 GB of RAM for the server, plus separate agents for the build workload. The agents can be VMs or Kubernetes pods using JetBrains's official agent Docker images. Most production deployments use a Postgres backend (the default in-memory HSQL is fine for evaluation but not production), which adds the cost of a small RDS or self-hosted Postgres instance.
Operator overhead lands at 2-6 hours per month for a typical mid-size deployment: occasional plugin upgrades, agent scaling adjustments, database vacuum operations, and the every-six-months major-version upgrade. The upgrades are largely undramatic; JetBrains is conservative with breaking changes and most version-to-version upgrades work without configuration changes.
Related deep dives
Frequently Asked Questions
# click any question to expand