cvat Documentation

GitHub

Computer Vision Annotation Tool (CVAT) is a leading platform for building high-quality visual datasets for vision AI. It offers open-source, cloud, and...

16,489 stars

Python 1 file · ~3,398 tokens #annotation #annotation-tool #annotations #boundingbox #computer-vision #computer-vision-annotation #dataset #deep-learning

RAW Doc

Docker & Self-Hosted Deployment Verified OCI

Deploy cvat on any server, homelab, or cloud container platform.

Raw YAML Docker Page → JSON API

1-Click Terminal Command

bash (docker run)

docker run -d --name cvat -p 8080:8080 --restart always postgres:15-alpine

Configured Services & Ports

⚙️ cvat_db

image: postgres:15-alpine

⚙️ cvat_redis_inmem

image: redis:7.2.11-alpine

⚙️ cvat_redis_ondisk

image: apache/kvrocks:2.15.0

⚙️ cvat_server

image: cvat/server:${CVAT_VERSION:-dev}

⚙️ cvat_worker_utils

image: cvat/server:${CVAT_VERSION:-dev}

⚙️ cvat_worker_import

image: cvat/server:${CVAT_VERSION:-dev}

⚙️ cvat_worker_export

image: cvat/server:${CVAT_VERSION:-dev}

⚙️ cvat_worker_annotation

image: cvat/server:${CVAT_VERSION:-dev}

⚙️ cvat_worker_webhooks

image: cvat/server:${CVAT_VERSION:-dev}

⚙️ cvat_worker_quality_reports

image: cvat/server:${CVAT_VERSION:-dev}

⚙️ cvat_worker_chunks

image: cvat/server:${CVAT_VERSION:-dev}

⚙️ cvat_worker_consensus

image: cvat/server:${CVAT_VERSION:-dev}

⚙️ cvat_ui

image: cvat/ui:${CVAT_VERSION:-dev}

⚙️ traefik

image: traefik:v3.6

🔌 Ports: 8080:8080, 8090:8090

⚙️ cvat_opa

image: openpolicyagent/opa:1.12.2

⚙️ cvat_clickhouse

image: clickhouse/clickhouse-server:23.11-alpine

⚙️ cvat_vector

image: timberio/vector:0.26.0-alpine

⚙️ cvat_grafana

image: grafana/grafana-oss:10.1.2

docker-compose.yml

yaml (docker-compose.yml)

# Copyright (C) 2018-2022 Intel Corporation
# Copyright (C) CVAT.ai Corporation
#
# SPDX-License-Identifier: MIT

name: cvat

x-backend-env: &backend-env
  CVAT_POSTGRES_HOST: cvat_db
  CVAT_REDIS_INMEM_HOST: cvat_redis_inmem
  CVAT_REDIS_INMEM_PORT: 6379
  CVAT_REDIS_ONDISK_HOST: cvat_redis_ondisk
  CVAT_REDIS_ONDISK_PORT: 6666
  CVAT_LOG_IMPORT_ERRORS: 'true'
  CVAT_ALLOW_STATIC_CACHE: '${CVAT_ALLOW_STATIC_CACHE:-no}'
  CVAT_DEFAULT_BACKING_CS_ID:
  CVAT_NUM_PROXIES: '${CVAT_NUM_PROXIES:-1}'
  DJANGO_LOG_SERVER_HOST: vector
  DJANGO_LOG_SERVER_PORT: 8282
  no_proxy: clickhouse,grafana,vector,nuclio,opa,${no_proxy:-}
  SMOKESCREEN_OPTS: ${SMOKESCREEN_OPTS:-}

x-backend-deps: &backend-deps
  cvat_redis_inmem:
    condition: service_started
  cvat_redis_ondisk:
    condition: service_started
  cvat_db:
    condition: service_started
  cvat_clickhouse:
    condition: service_started

x-clickhouse-env: &clickhouse-env
  CLICKHOUSE_HOST: clickhouse
  CLICKHOUSE_PORT: 8123
  CLICKHOUSE_DB: cvat
  CLICKHOUSE_USER: user
  CLICKHOUSE_PASSWORD: user

services:
  cvat_db:
    container_name: cvat_db
    image: postgres:15-alpine
    restart: always
    environment:
      POSTGRES_USER: root
      POSTGRES_DB: cvat
      POSTGRES_HOST_AUTH_METHOD: trust
    volumes:
      - cvat_db:/var/lib/postgresql/data
    networks:
      - cvat

  cvat_redis_inmem:
    container_name: cvat_redis_inmem
    image: redis:7.2.11-alpine
    restart: always
    command: [
      "redis-server",
      "--save", "60", "100",
      "--appendonly", "yes",
    ]
    volumes:
      - cvat_inmem_db:/data
    networks:
      - cvat

  cvat_redis_ondisk:
    container_name: cvat_redis_ondisk
    image: apache/kvrocks:2.15.0
    restart: always
    # The kvrocks image a) has a healthcheck command, and b) has a root process
    # that doesn't reap children, so it's susceptible to the problem described here:
    # . Kvrocks also uses a tiny timeout for
    # its healthcheck command (1s), which makes the problem more likely to manifest.
    # Use a separate init process as a workaround.
    init: true
    volumes:
      - cvat_cache_db:/var/lib/kvrocks
    networks:
      - cvat
    command: [
      "--compact-cron", "0 3 * * *",
      ]

  cvat_server:
    container_name: cvat_server
    image: cvat/server:${CVAT_VERSION:-dev}
    restart: always
    depends_on:
      <<: *backend-deps
      cvat_opa:
        condition:
          service_started
    environment:
      <<: [*backend-env, *clickhouse-env]
      DJANGO_MODWSGI_EXTRA_ARGS: ''
      ALLOWED_HOSTS: '*'
      ADAPTIVE_AUTO_ANNOTATION: 'false'
      NUMPROCS: 2
      CVAT_ANALYTICS: 1
      CVAT_BASE_URL:
      ONE_RUNNING_JOB_IN_QUEUE_PER_USER:
    command: init run server nginx
    labels:
      traefik.enable: "true"
      traefik.http.services.cvat.loadbalancer.server.port: "8080"
      traefik.http.routers.cvat.rule:
        Host(`${CVAT_HOST:-localhost}`) &&
        (PathPrefix(`/api/`) || PathPrefix(`/static/`) || PathPrefix(`/admin`)
          || PathPrefix(`/django-rq`))
      traefik.http.routers.cvat.entrypoints: web
    volumes:
      - cvat_data:/home/django/data
      - cvat_keys:/home/django/keys
      - cvat_logs:/home/django/logs
    networks:
      cvat:
        aliases:
          - cvat-server

  cvat_worker_utils:
    container_name: cvat_worker_utils
    image: cvat/server:${CVAT_VERSION:-dev}
    restart: always
    depends_on: *backend-deps
    environment:
      <<: *backend-env
      CVAT_REDIS_INMEM_PASSWORD: ''
      NUMPROCS: 1
    command: run worker notifications cleaning
    volumes:
      - cvat_data:/home/django/data
      - cvat_keys:/home/django/keys
      - cvat_logs:/home/django/logs
    networks:
      - cvat

  cvat_worker_import:
    container_name: cvat_worker_import
    image: cvat/server:${CVAT_VERSION:-dev}
    restart: always
    depends_on: *backend-deps
    environment:
      <<: *backend-env
      NUMPROCS: 2
    command: run worker import --with-scheduler
    volumes:
      - cvat_data:/home/django/data
      - cvat_keys:/home/django/keys
      - cvat_logs:/home/django/logs
    networks:
      - cvat

  cvat_worker_export:
    container_name: cvat_worker_export
    image: cvat/server:${CVAT_VERSION:-dev}
    restart: always
    depends_on: *backend-deps
    environment:
      <<: [*backend-env, *clickhouse-env]
      NUMPROCS: 2
    command: run worker export --with-scheduler
    volumes:
      - cvat_data:/home/django/data
      - cvat_keys:/home/django/keys
      - cvat_logs:/home/django/logs
    networks:
      - cvat

  cvat_worker_annotation:
    container_name: cvat_worker_annotation
    image: cvat/server:${CVAT_VERSION:-dev}
    restart: always
    depends_on: *backend-deps
    environment:
      <<: *backend-env
      NUMPROCS: 1
    command: run worker annotation
    volumes:
      - cvat_data:/home/django/data
      - cvat_keys:/home/django/keys
      - cvat_logs:/home/django/logs
    networks:
      - cvat

  cvat_worker_webhooks:
    container_name: cvat_worker_webhooks
    image: cvat/server:${CVAT_VERSION:-dev}
    restart: always
    depends_on: *backend-deps
    environment:
      <<: *backend-env
      NUMPROCS: 1
    command: run worker webhooks --with-scheduler
    volumes:
      - cvat_data:/home/django/data
      - cvat_keys:/home/django/keys
      - cvat_logs:/home/django/logs
    networks:
      - cvat

  cvat_worker_quality_reports:
    container_name: cvat_worker_quality_reports
    image: cvat/server:${CVAT_VERSION:-dev}
    restart: always
    depends_on: *backend-deps
    environment:
      <<: *backend-env
      NUMPROCS: 1
    command: run worker quality_reports
    volumes:
      - cvat_data:/home/django/data
      - cvat_keys:/home/django/keys
      - cvat_logs:/home/django/logs
    networks:
      - cvat

  cvat_worker_chunks:
    container_name: cvat_worker_chunks
    image: cvat/server:${CVAT_VERSION:-dev}
    restart: always
    depends_on: *backend-deps
    environment:
      <<: *backend-env
      NUMPROCS: 2
    command: run worker chunks
    volumes:
      - cvat_data:/home/django/data
      - cvat_keys:/home/django/keys
      - cvat_logs:/home/django/logs
    networks:
      - cvat

  cvat_worker_consensus:
    container_name: cvat_worker_consensus
    image: cvat/server:${CVAT_VERSION:-dev}
    restart: always
    depends_on: *backend-deps
    environment:
      <<: *backend-env
      NUMPROCS: 1
    command: run worker consensus
    volumes:
      - cvat_data:/home/django/data
      - cvat_keys:/home/django/keys
      - cvat_logs:/home/django/logs
    networks:
      - cvat

  cvat_ui:
    container_name: cvat_ui
    image: cvat/ui:${CVAT_VERSION:-dev}
    restart: always
    depends_on:
      - cvat_server
    labels:
      traefik.enable: "true"
      traefik.http.services.cvat-ui.loadbalancer.server.port: "8000"
      traefik.http.routers.cvat-ui.rule: Host(`${CVAT_HOST:-localhost}`)
      traefik.http.routers.cvat-ui.entrypoints: web
    networks:
      - cvat

  traefik:
    image: traefik:v3.6
    container_name: traefik
    restart: always
    ports:
      - 8080:8080
      - 8090:8090
    environment:
      CVAT_HOST: ${CVAT_HOST:-localhost}
      DJANGO_LOG_VIEWER_HOST: grafana
      DJANGO_LOG_VIEWER_PORT: 3000

      TRAEFIK_ACCESSLOG_FORMAT: json
      TRAEFIK_ACCESSLOG_FIELDS_DEFAULTMODE: drop
      TRAEFIK_ACCESSLOG_FIELDS_NAMES_ClientHost: keep
      TRAEFIK_ACCESSLOG_FIELDS_NAMES_DownstreamContentSize: keep
      TRAEFIK_ACCESSLOG_FIELDS_NAMES_DownstreamStatus: keep
      TRAEFIK_ACCESSLOG_FIELDS_NAMES_Duration: keep
      TRAEFIK_ACCESSLOG_FIELDS_NAMES_RequestHost: keep
      TRAEFIK_ACCESSLOG_FIELDS_NAMES_RequestMethod: keep
      TRAEFIK_ACCESSLOG_FIELDS_NAMES_RequestPath: keep
      TRAEFIK_ACCESSLOG_FIELDS_NAMES_RequestPort: keep
      TRAEFIK_ACCESSLOG_FIELDS_NAMES_RequestProtocol: keep
      TRAEFIK_ACCESSLOG_FIELDS_NAMES_RouterName: keep
      TRAEFIK_ACCESSLOG_FIELDS_NAMES_StartUTC: keep

      TRAEFIK_LOG_FORMAT: json
      TRAEFIK_ENTRYPOINTS_web_ADDRESS: :8080
      TRAEFIK_PROVIDERS_DOCKER_EXPOSEDBYDEFAULT: "false"
      TRAEFIK_PROVIDERS_DOCKER_NETWORK: cvat
      TRAEFIK_PROVIDERS_FILE_DIRECTORY: /etc/traefik/rules
    # Uncomment to get Traefik dashboard
    #   TRAEFIK_API_DASHBOARD: "true"
    #   TRAEFIK_ENTRYPOINTS_dashboard_ADDRESS: :8090
    # labels:
    #   traefik.enable: "true"
    #   traefik.http.routers.dashboard.entrypoints: dashboard
    #   traefik.http.routers.dashboard.service: api@internal
    #   traefik.http.routers.dashboard.rule: Host(`${CVAT_HOST:-localhost}`)
    volumes:
      - /var/run/docker.sock:/var/run/docker.sock:ro
      - ./components/analytics/grafana_conf.yml:/etc/traefik/rules/grafana_conf.yml:ro
    networks:
      - cvat
    logging:
      driver: "json-file"
      options:
        max-size: 100m
        max-file: "10"

  cvat_opa:
    container_name: cvat_opa
    image: openpolicyagent/opa:1.12.2
    restart: always
    networks:
      cvat:
        aliases:
          - opa
    command:
      - run
      - --server
      - --addr=:8181
      - --log-level=error
      - --set=services.cvat.url=http://cvat-server:8080
      - --set=bundles.cvat.service=cvat
      - --set=bundles.cvat.resource=/api/auth/rules
      - --set=bundles.cvat.polling.min_delay_seconds=5
      - --set=bundles.cvat.polling.max_delay_seconds=15

  cvat_clickhouse:
    container_name: cvat_clickhouse
    image: clickhouse/clickhouse-server:23.11-alpine
    restart: "always"
    environment:
      <<: *clickhouse-env
    networks:
      cvat:
        aliases:
          - clickhouse
    volumes:
      - cvat_events_db:/var/lib/clickhouse/

  cvat_vector:
    container_name: cvat_vector
    image: timberio/vector:0.26.0-alpine
    user: "1000:1000" # Workaround for .
    restart: always
    depends_on:
      - cvat_clickhouse
    environment:
      <<: *clickhouse-env
    networks:
      cvat:
        aliases:
          - vector
    volumes:
      - type: bind
        source: ./components/analytics/vector/vector.toml
        target: /etc/vector/vector.toml
        read_only: true
      - type: tmpfs
        target: /vector-data-dir

  cvat_grafana:
    image: grafana/grafana-oss:10.1.2
    restart: always
    container_name: cvat_grafana
    environment:
      <<: *clickhouse-env
      GF_PATHS_PROVISIONING: /etc/grafana/provisioning
      GF_AUTH_BASIC_ENABLED: false
      GF_AUTH_ANONYMOUS_ENABLED: true
      GF_AUTH_ANONYMOUS_ORG_ROLE: Admin
      GF_AUTH_DISABLE_LOGIN_FORM: true
      GF_SERVER_ROOT_URL: http://${CVAT_HOST:-localhost}/analytics
      GF_INSTALL_PLUGINS: 'grafana-clickhouse-datasource 4.8.2'
      GF_DASHBOARDS_DEFAULT_HOME_DASHBOARD_PATH: /var/lib/grafana/dashboards/all_events.json
    volumes:
      - ./components/analytics/grafana/dashboards/:/var/lib/grafana/dashboards/:ro
    entrypoint:
      - sh
      - -euc
      - |
        mkdir -p /etc/grafana/provisioning/datasources
        cat << 'EOF' > /etc/grafana/provisioning/datasources/ds.yaml
        apiVersion: 1
        datasources:
          - name: 'ClickHouse'
            type: 'grafana-clickhouse-datasource'
            isDefault: true
            jsonData:
              defaultDatabase: $${CLICKHOUSE_DB}
              port: $${CLICKHOUSE_PORT}
              server: $${CLICKHOUSE_HOST}
              username: $${CLICKHOUSE_USER}
              tlsSkipVerify: false
              protocol: http
            secureJsonData:
              password: $${CLICKHOUSE_PASSWORD}
            editable: true
        EOF
        mkdir -p /etc/grafana/provisioning/dashboards
        cat << EOF > /etc/grafana/provisioning/dashboards/dashboard.yaml
        apiVersion: 1
        providers:
          - name: cvat-logs
            type: file
            updateIntervalSeconds: 30
            options:
              path:  /var/lib/grafana/dashboards
              foldersFromFilesStructure: true
        EOF
        exec /run.sh
    networks:
      cvat:
        aliases:
          - grafana

volumes:
  cvat_db:
  cvat_data:
  cvat_keys:
  cvat_logs:
  cvat_inmem_db:
  cvat_events_db:
  cvat_cache_db:

networks:
  cvat:

CVAT: Computer Vision Annotation Tool

Website ·
Docs ·
Changelog ·
Tutorials ·
Academy ·
Blog

What is CVAT Community?

CVAT Community is the free, self-hosted open-source edition of CVAT — one of
the most widely used data annotation platforms for building high-quality visual datasets for
computer vision and visual AI.
Since 2018, CVAT has become one of the best-known data annotation tools in computer vision, with a
large open-source community, millions of Docker pulls, and broad adoption across research and
production AI teams.

CVAT Community supports image, video, and 3D annotation, dataset management, team collaboration, cloud storage
integration, developer-friendly SDKs and APIs, and gives your team full control over your data
and annotation infrastructure.
The platform serves as the foundation of
CVAT Online and
CVAT Enterprise, and is actively maintained by the CVAT engineering team.

Why teams choose CVAT Community:

Own your data: Run entirely within your own infrastructure. No data leaves your environment.
AI-powered annotation: Connect your own ML models for detection, segmentation, and tracking to speed up labeling.
Team collaboration: Multi-user and multi-organization support with roles, task assignments,
and review workflows.
MIT-licensed core: Use, modify, and distribute CVAT Community under the permissive MIT License. Some serverless
assets and dependencies may have separate licenses.
Production-grade: The foundation of all CVAT commercial products — battle-tested at scale.
True open-source: Transparent development, active community, on GitHub since 2018.

This repository contains the source code and deployment assets for CVAT Community.

For a fully managed setup, annotation services, or enterprise features, see
CVAT Online,
CVAT Enterprise and
CVAT Labeling Services.

Getting Started

💡 Want to explore CVAT before deploying anything?
Try CVAT Online (Free plan) directly in your browser.
Feature availability and usage limits vary by plan; see
CVAT Online pricing for details.

Installation

Prerequisites:

💡 CVAT is primarily tested with Chromium-based browsers (Google Chrome, Microsoft Edge).
Firefox may work with some caveats; Safari/WebKit is not supported.

1. Start the default stack

Clone the repository and launch the services.

bash

git clone https://github.com/cvat-ai/cvat
cd cvat

# Optional: set your IP or domain
# export CVAT_HOST=your-ip-or-domain

docker compose up -d

2. Create an admin account

bash

docker exec -it cvat_server bash -ic 'python3 ~/manage.py createsuperuser'

See the Installation Guide for full
instructions and OS-specific setup.

3. Sign in and start labeling

Open http://localhost:8080 (or your CVAT_HOST) in your browser.
Log in with your superuser account.
Create a project or task, upload your data (images, videos, or point clouds), and define labels to start annotating.

Learn more about annotation tools and workflows in the CVAT Documentation or
take our free course – CVAT Academy.

For alternative deployments (AWS, Kubernetes, external PostgreSQL, backups, upgrades), see the Deployment Guides.

Key Capabilities

Manual & Auto-labeling: Annotate images, videos, and
3D point clouds with bounding boxes, polygons, masks, keypoints, cuboids, tags, and more. Speed up labeling
by connecting your own models for automatic annotation.
Task Management: Organize datasets into projects, split them into tasks
and jobs, assign work to annotators, and track progress in real time.
Collaboration: Create organizations, invite teammates,
assign roles, and collaborate on annotations with comments and issues.
Quality Control: Review annotations, flag issues, compare
results across annotators with consensus, and run Ground Truth and Honeypot checks through the server API.
Analytics: Monitor user activity,
working time by job, events, and server logs with Grafana dashboards.
Data Ops & Integrations: Export/import in 20+
formats (COCO, YOLO, Pascal VOC, KITTI, etc.), connect to cloud storage (S3, Azure, Google Cloud), and automate
via REST API and Python SDK.

Advanced capabilities such as advanced project analytics, quality control UI, built-in auto-labeling with SAM 2
and SAM 3, AI agents, SSO, and more are available in CVAT Online
paid plans (Solo, Team) and CVAT Enterprise.

Developer Tools

CVAT is designed for automation. Beyond the Web UI, you can integrate it into your pipelines using:

Python SDK: install with pip install cvat-sdk and automate task creation,
uploads, and exports from Python.
Command line tool: install with pip install cvat-cli
and script common CVAT workflows from the terminal.
REST API: full programmatic control over CVAT.

Data and Formats

CVAT Community supports image, video, and 3D (point cloud) annotation workflows. You can move data in and out using 20+
industry-standard formats: CVAT (XML), COCO (JSON), YOLO (TXT), Ultralytics YOLO (TXT/YAML), Pascal VOC (XML),
KITTI (TXT), MOT (TXT), and more.

Full list of supported formats.

ML and AI Models

CVAT Community supports automatic annotation via pre-built serverless models powered by Nuclio,
covering detection, segmentation, pose estimation, and tracking:

Model	Framework	Type
Segment Anything (SAM)	PyTorch	Interactor
Inside-Outside Guidance (IOG)	PyTorch	Interactor
RetinaNet R101	PyTorch	Detector
HRNet32 Whole Body Pose	PyTorch	Pose Estimation
TransT	PyTorch	Tracker
YOLO v7	ONNX	Detector
Mask RCNN Inception ResNet v2	OpenVINO	Detector
Face Detection 0205	OpenVINO	Detector
Faster RCNN Inception v2	TensorFlow	Detector

To enable automatic annotation, add the serverless component to your deployment:

bash

docker compose -f docker-compose.yml -f components/serverless/docker-compose.serverless.yml up -d

This starts the serverless infrastructure. To make models available in CVAT, install nuctl and deploy
the functions you need, for example SAM or YOLO, as described in the Automatic Annotation Guide.

Which CVAT edition should I choose?

CVAT Online: the fastest way to try CVAT and start labeling without deployment. Use it to evaluate CVAT in
the browser, explore managed features, and move to cost-efficient paid plans when you need more capacity or team
workflows.
CVAT Community: the MIT-licensed self-hosted edition for teams that want to run CVAT themselves, customize the
stack, and control their infrastructure.
CVAT Enterprise: for organizations that need CVAT in their own cloud or internal environment, enterprise support,
security controls such as SSO, paid platform features, and SLAs.
Labeling Services: for teams that want to outsource annotation work to CVAT.ai’s experienced labeling team instead
of building an internal labeling operation. Customers get trial access to CVAT Online during the project.

For detailed plan limits and feature availability, see CVAT Online pricing,
CVAT Enterprise, and Labeling Services.

Support

Usage questions: ask the community on Discord or
Stack Overflow with the cvat tag.
Bugs and feature requests: use GitHub Issues.
FAQ: Installation, upgrades, troubleshooting.

For dedicated support, SLAs, or advanced deployments, consider CVAT Enterprise.

Contributing

We welcome all contributions: bug reports, documentation fixes, integrations, and code.

If you'd like to contribute to CVAT, please refer to our
contribution documentation.
For bug reports or feature requests, please use the GitHub Issues tracker.

Security

Please review our Security Policy before reporting vulnerabilities.
For sensitive issues, contact: [email protected].

License

CVAT Community is released under the MIT License.

Code in /serverless is also MIT-licensed, but may use third-party assets under separate licenses (including
non-commercial). Review those licenses before use.
This software uses FFmpeg libraries under LGPL/GPL. See the Dockerfile and
FFmpeg legal info for details.

Additional Resources

For the latest product releases, feature walkthroughs, and all things CVAT see:

Docker & Self-Hosted Deployment Verified OCI

CVAT: Computer Vision Annotation Tool

What is CVAT Community? Copy Chapter

Getting Started Copy Chapter

Installation Copy Section

Key Capabilities Copy Chapter

Developer Tools Copy Chapter

Data and Formats Copy Chapter

ML and AI Models Copy Chapter

Which CVAT edition should I choose? Copy Chapter

Support Copy Chapter

Contributing Copy Chapter

Security Copy Chapter

License Copy Chapter

Additional Resources Copy Chapter

Explore Related Technologies & Topics

What is CVAT Community?

Getting Started

Installation

Key Capabilities

Developer Tools

Data and Formats

ML and AI Models

Which CVAT edition should I choose?

Support

Contributing

Security

License

Additional Resources