You are viewing the documentation of TeamCity 2018.x, which is not the most recently released version of TeamCity.
View this page in the latest documentation or refer to the listing to choose the documentation corresponding to your TeamCity version.


Versions Compared


  • This line was added.
  • This line was removed.
  • Formatting was changed.


To install a TeamCity server, perform the following:


Installing TeamCity Server

After you obtained selected one of the the TeamCity installation packageoptions, proceed with corresponding installation instructions:

  • Windows .exe distribution - the executable which provides the installation wizard for Windows platforms and allows installing the server as a Windows service;
  • .tar.gz distribution - the archive with a "portable" version suitable for all platforms;
  • Docker image - check the instructions at the image page;
  • .war distribution - for experienced users who want to run TeamCity in a separately installed Web application server. Please consider using .tar.gz distribution instead. .war is not recommended to use unless really required (please let us know the reasons).


  • include a Tomcat version which TeamCity is tested with, so it is known to be a working combination. This might not be the case with an external Tomcat.
  • define additional JRE options which are usually recommended for running the server
  • have the teamcity-server startup script which provides several convenience options (e.g. separate environment variable for memory settings) and configures TeamCity correctly (e.g. log4j configuration)
  • (at least under Windows) provide better error reporting for some cases (like a missing Java installation)
  • under Windows, allow running TeamCity as a service with the ability to use the same configuration as if run from the console
  • come bundled with a build agent distribution and single startup script which allows for easy TeamCity server evaluation with one agent
  • come bundled with the devPackage for TeamCity plugin development.
  • may provide more convenience features in the future


If you cannot access the TeamCity web UI after successful installation, please refer to the #Troubleshooting TeamCity Installation Issues section.


(info) The build server and one build agent will be installed by default for Windows, Linux or MacOS XmacOS. If you need more build agents, refer to the Installing Additional Build Agents section.


(warning) During the server setup you can select either an internal database or an existing external database. By default, TeamCity uses an HSQLDB database that does not require configuring. This database suites the purposes of testing and evaluating the system.
For production purposes, using a standalone external database is recommended.


If you opted to install the services, use the standard Windows Services applet to manage the service.
Otherwise, use standard scripts.

If you did not change the default port (80) during the installation, the TeamCity web UI can be accessed via "http://localhost/" address in  in a web browser running on the same machine where the server is installed. Please note that port 80 can be used by other programs (e.g. Skype, or other web servers like IIS). In this case you can specify another port during the installation and use "http://localhost:<port>/ " address in the browser.



Installing TeamCity bundled with Tomcat servlet container (Linux, Mac OS X, Windows)
Installing TeamCity bundled with Tomcat servlet container (Linux, Mac OS X, Windows)

Installing TeamCity bundled with Tomcat servlet container (Linux, macOS, Windows)

Review software requirements before the installation.


Ensure you have JRE or JDK installed and the JAVA_HOME environment variable is pointing to the Java installation directory. Oracle Java 8 JDK is JDK 1.8.0_16 or later is required.



It is not recommended to use .war distribution. Use the TeamCity .tar.gz distribution (bundled with Tomcat web server) instead. If you have important reasons to deploy TeamCity into existing web server and want to use .war distribution, please let us know the reasons.

  1. Make sure your web application server is stopped.
  2. Copy the downloaded TeamCity<version number>.war file into the web applications directory of your J2EE container under the TeamCity.war name (the name of the file is generally used as a part of the URL) or deploy the .war following the documentation of the web server. Please make sure there is no other version of TeamCity deployed (e.g. do not preserve the old TeamCity web application directory under the web server applications directory).
  3. Ensure the TeamCity web application gets sufficient amount of memory. Please increase the memory accordingly if you have other web applications running in the same JVM.
  4. If you are deploying TeamCity to the Tomcat container, please add useBodyEncodingForURI="true" attribute to the main Connector tag for the server in the Tomcat/conf/server.xml file.
  5. If you are deploying TeamCity to Jetty container version >7.5.5 (including 8.x.x), please make sure the system property org.apache.jasper.compiler.disablejsr199 is set to true
  6. Ensure that the servlet container is configured to unpack the deployed war files. Though for most servlet containers it is the default behavior, for some it is not (e.g. Jetty version >7.0.2) and should be explicitly configured. TeamCity is not able to work from a packed .war: if started this way, there will be a note on this the logs and UI.
  7. Configure the appropriate TeamCity Data Directory to be used by TeamCity. 


    Note that it is recommended to start with an empty TeamCity Data Directory. After completing the installation and performing the first TeamCity server start, the required data (e.g. database settings file) can be moved to the directory.

  8. Check/configure the TeamCity logging properties by specifying the log4j.configuration and teamcity_logs internal properties.
  9. Restart the server or deploy the application via the servlet container administration interface and access http://server:port/TeamCity/, where "TeamCity" is the name of the war file.


For automated server installation, use the .tar.gz distribution.

Typically, you will need to unpack it and make the script perform the steps noted in Configuring Server for Production Use section.

If you want to get a pre-configured server right away, put files from a previously configured server into the Data Directory. For each new server you will need to ensure it points to a new database (configured in <Data Directory>\config\database.properties) and change <Data Directory>\config\main-config.xml file not to have the "uuid" attribute in the root XML element (so new one can be generated) and setting appropriate value for "rootURL" attribute.


Notes on configuring Windows for the server setup (based on Windows Server 2016):
- enable Remote desktop connections
- create dedicated user (e.g. "TeamCity") and assign it administrator permissions
- disable disk indexing for all disks (or at least for the disks where TeamCity home and TeamCity Data Directory are located)
- disable real-time protection и cloud-based protection in Windows Defender
- check Windows Firewall is enabled (counter-intuitively this changes Windows network stack behavior to handle more incoming but not yet accepted network connections)
on Windows Firewall settings:
-- enable incoming connections to TeamCity application ports
-- enable ICMP pings
-- enable ports for monitoring agent, etc.
- (if IPv6 network is not used) disable ipv6 on network adapter settings
- disable weekly schedule for fragmentation analyzing
- disable "Optimize drive" service
- (for manual updates application) set Windows updates policy to "DownloadOnly" via sconfig utility
- consider enabling jumbo frames and ensuring that the network supports the setting (check that all the related network infrastructure supports it e.g. via "ping -l 8960 -f <host>")

Using another Version of Tomcat

If you want to To use another version of the Tomcat web server instead of the one bundled in the .tar.gz and .exe distributions), you have the choices of whether to can either use the .war TeamCity distribution (not recommended) or perform the Tomcat upgrade/patch for TeamCity installed from the .exe or .tar.gz distributions.

For the latter, you might want to:



Starting TeamCity server

If Under Windows, if TeamCity server is installed as a Windows service, follow the usual procedure of starting and stopping services.

If TeamCity is installed using the .exe or .tar.gz distributions, the TeamCity server can be started and stopped by the teamcity-server scripts provided in the <TeamCity home>/bin directory.
The script accepts run (run in the same console), start (start new detached process and exit from the script) and stop commands.

  • (evaluation only) To start/stop the TeamCity server and one default agent at the same time, use the runAll script, e.g.:
    • Use runAll.bat start to start the server and the default agent
    • Use runAll.bat stop to stop the server and the default agent



The TeamCity server will restart automatically if the Java process of  the server crashes since TeamCity 2017.2.server process exits (crashes or is killed) without invoking "teamcity-server stop" script.

By default, TeamCity runs on http://localhost:8111/ and has one registered build agent that runs on the same computer. See the information below for changing the server port.


If TeamCity is installed into an existing web server (.war distribution), start the server according to its documentation. Make sure you configure TeamCity-specific logging-related properties and pass suitable memory options.

Autostart TeamCity server on Mac OS X
Autostart TeamCity server on Mac OS X

Autostart TeamCity server on macOS

Starting up TeamCity server on Mac macOS is quite similar to starting Tomcat on MacmacOS.

  1. Install TeamCity and make sure it works if started from the command line with bin/teamcity-server.sh start. We'll assume that TeamCity is installed in the /Library/TeamCity folder
  2. Create the /Library/LaunchDaemons/jetbrains.teamcity.server.plist file with the following content:

    Code Block
    <?xml version="1.0" encoding="UTF-8"?>
    <!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
    <plist version="1.0">
            <string>bin/teamcity-server.sh run</string>
  3. Test your file by running launchctl load /Library/LaunchDaemons/jetbrains.teamcity.server.plist . This command should start the TeamCity server (you can see this from logs/teamcity-server.log and in your browser). 

  4. If you don't want TeamCity to start under the root permissions, specify the UserName key in the plist file, e.g.:

    Code Block


One of the most common issues with the server installation is using a port that is already used by another program. See below on changing the default port.


If you use the TeamCity server Windows installer, you can set the port to be used during installation.If you use the .war distribution, refer to the manual of the application server used.

Use the following instructions to change the port if you use the .tar.gz distribution.
If another application uses the same port as the TeamCity server, the TeamCity server (Tomcat server) won't start and this will be identified by "Address already in use" errors in the server logs or server console.


To apply the changes, restart the server. If the server was working with the old port previously, you would need to change the port in all the stored URLs of the server (browser bookmarks, agents' serverUrl property, URL in user's IDEs, "Server URL" setting on the "Administration | Global Settings" Settings page).

If you run another Tomcat server on the same machine, you might need to also change other Tomcat server service ports (search for "port=" in the server.xml file).

If you want to use the https:// protocol, it should be enabled separately and the process is not specific to TeamCity, but rather for the web server used (Tomcat by default). See also Using Configure HTTPS to access for TeamCity serverWeb UI



The TeamCity server requires JRE 8 to operate (download page)operate, the agent can run with Java 6-10, but Java 8 is recommended. The recommended Oracle download is Java SE JDKJava download is AdoptOpenJDK.
It is recommended to use the 32-bit installation unless you need to dedicate more memory to TeamCity server. Please check the 64-bit Java notes before upgrade.
If you configured any native libraries for use with TeamCity (like a .dll for using Microsoft SQL database Integrated Security option), you need to update the libraries to match the JVM x86/x64 platform.

For TeamCity agent Java requirements, check Setting up and Running Additional Build Agents.

TeamCity selects the Java to run the server process as follows:

  • If your TeamCity installation has a bundled JRE (there is the <TeamCity Home>\jre  directory), it will always be used to run the TeamCity server process.
  • If there is no <TeamCity Home>\jre  directory present, set JRE_HOME or JAVA_HOME environment variables pointing to the installation directories of JRE or JVM (Java SDK) respectively. JRE will be used if both are present.

The necessary steps to update the Java installation depend on the distribution used.


TeamCity server can run under both the 32- and 64-bit JVM.
It is recommended to use the 32-bit JVM unless you need to dedicate more than 1.2Gb 1Gb of memory (via -Xmx JVM option) to the TeamCity process (see details) or your database requirements are different.

If you choose to use the 64-bit JVM, note that the memory usage is almost doubled when switching from the 32- to 64-bit JVM, so please make sure you specify at least twice as much memory as for 32-bit JVM, see #Setting Up Memory settings for TeamCity Server.

To update to the 64-bit Java:

  • update Java to be used by the server
  • set JVM memory options. It is recommended to set the following options for the 64-bit JVM: -Xmx4g -XX:ReservedCodeCacheSize=350m


Setting Up Memory settings for TeamCity Server

TeamCity server has the main process which can also launch child processes. Child processes use available memory on the machine, this section covers the memory settings of the main TeamCity server process only as it requires special configuration.
As a JVM application, TeamCity main server process only utilizes memory devoted to the JVM. The required memory may depend on the JVM used (32 bit or 64 bit). The memory used by JVM usually consists of: heap (configured via -Xmx) and metaspace (limited by the amount of available native memory), internal JVM (usually tens of Mb), and OS-dependent memory features like memory-mapped files. TeamCity mostly depends on the heap memory and this settings can be configured for the TeamCity application manually by passing -Xmx (heap space) option to the JVM running the TeamCity server.

Once you start using TeamCity for production purposes or you want to load the server during evaluation, you should manually set the appropriate memory settings for the TeamCity server.


  • minimum setting (the 32-bit Java should be used (bundled in .exe distribution)): -Xmx750m 
  • recommended setting for medium server use (the 32-bit Java should be used): -Xmx1024m.  Greater settings with the 32-bit Java can cause an OutOfMemoryError with "Native memory allocation (malloc) failed" JVM crashes or "unable to create new native thread" messages

  • recommended setting for large server use (64-bit Java should be used): -Xmx4g -XX:ReservedCodeCacheSize=350m.  These settings should be suitable for an installation with up to two hundreds of agents and thousands of build configurations. Custom plugins installed might require increasing the values defined via the Xmx parameter.
  • maximum settings for large-scale server use (64-bit Java should be used): -Xmx10g -XX:ReservedCodeCacheSize=512m. Greater values can be used for larger TeamCity installations. However, generally it is not recommended to use values greater than 10g without consulting TeamCity support.


  • the 32-bit JVM can reliably work with up to 1Gb heap memory (-Xmx1024m). (This can be increased to -Xmx1200m, but JVM under Windows might crash occasionally with this setting.) If more memory is necessary, the 64-bit JVM should be used with not less than 2.5Gb assigned (-Xmx2500m). ItUnless the TeamCity server runs with more than 100 agents or serves very active builds / thousands of users, it's highly unlikely that you will need to dedicate more than 4Gb of memory to the TeamCity process.
  • A rule of thumb is that the 64-bit JVM should be assigned twice as much memory as the 32-bit for the same application. If you switch to the 64-bit JVM, make sure you adjust the memory setting ( -Xmx) accordingly. It does not make sense to switch to 64 bit if you dedicate less than the double amount of memory to the application.
  • Large TeamCity installations might benefit from more fine tuning of the memory settings. The amount of memory dedicated to TeamCity server JVM should not regularly exceed 60% of the total available physical memory on the machine (to allow for nested process and OS-level caches usage). Also, with heaps (–Xmx) set to more than 8Gb, if the machine has many CPU cores (e.g. more than 8) and current CPU usage is below 60%, enabling G1 JVM garbage collector via "-XX:+UseG1GC" JVM option might reduce the length of stop-the-world GC pauses.

The recommended approach is to start with initial settings and monitor for the percentage of used memory using the Administration | Diagnostics page. If the server uses more than 80% of memory consistently without drops for tens of minutes, that is probably a sign to increase the -Xmx memory value by another 20%.

Wiki Markup

If you run TeamCity via {{runAll}} or {{teamcity-server}} scripts or via Windows service installed during TeamCity installation, the default setting of 512 Mb for the heap and 150 Mb for the PermGen are used. If you need to change the settings, please refer to [Configuring TeamCity Server Startup Properties|Configuring TeamCity Server Startup Properties#JVMProperties]. If you run TeamCity using .war distribution please refer to the manual of the application server to change the memory settings. The actual memory consumption will be (e.g. 100Mb) higher since JVM itself uses memory too.



Out-of-the-box TeamCity server installation is suitable for evaluation purposes. For production use you will need to perform additional configuration which typically includes:

    Configuring correct server port (and )
  • Make sure server URL, email and (optionally) Jabber server settings are specified and are correct
  • Configuring the server process for OS-dependent autostart on machine reboot
  • Using reliable storage for TeamCity Data Directory
  • Using external database
  • Configuring recommended memory settings, use "maximum settings" for active or growing servers
  • Planning for regular backups
  • Planning for regular upgrades to the latest TeamCity releases
  • (since TeamCity 10.0.3) Consider adding the "teamcity.installation.completed=true" line into the <TeamCity Home Directory>\conf\teamcity-startup.properties file - this will prevent the server from creating an administrator user if no such user is found

     See https://youtrack.jetbrains.com/issue/TW-20027 for details