Label Studio

Label Studio is an open-source data labeling tool built by HumanSignal that supports annotation across all major data types: images, text, HTML, audio, video, time series, and PDF. Teams configure their labeling interfaces using a declarative XML-based configuration language, selecting from over 30 built-in tags such as bounding boxes, polygons, named entity spans, audio regions, and timeline labels without writing any frontend code.

The platform ships as a Python pip package backed by a Django REST API and a React/mobx-state-tree frontend editor. Projects organize collections of tasks, which are individual items to annotate. Annotations are recorded at the task level, support multiple annotators per task for consensus scoring, and can be compared side-by-side. Pre-labeling is supported by connecting external ML backends over HTTP, which Label Studio calls for predictions before a human reviews and refines them.

Cloud storage integrations (Amazon S3, Google Cloud Storage, Azure Blob Storage, and local filesystem) allow teams to read source data and write annotation results directly to their own buckets without staging files through Label Studio itself. Completed annotations export in a wide range of ML-framework formats including COCO, Pascal VOC, YOLO, spaCy, and plain JSON via the label-studio-sdk converter library.

Label Studio Enterprise (Label Studio’s commercial edition by HumanSignal) extends the open-source core with SSO, role-based access control, team workspaces, analytics dashboards, and SLA-backed support. The community edition is fully functional for teams running their own infrastructure and willing to manage the operational stack themselves.

What You Get

• A declarative XML labeling configuration system with 30+ built-in tags covering bounding boxes, polygons, semantic segmentation brushes, NER spans, sentiment choices, audio timeline regions, and video keyframe labels
• Multi-annotator support with per-task assignment, annotation comparison views, and inter-annotator agreement scoring to measure labeling consistency
• Native cloud storage sync (AWS S3, GCS, Azure Blob, Redis, local filesystem) that reads source data and writes annotations back without requiring you to upload files to Label Studio
• An ML backend API that accepts external prediction servers for pre-labeling, interactive annotation (model responds to each stroke or click in real time), and active learning loops
• Webhook support for triggering downstream pipelines when annotations are created, updated, or submitted
• Export to COCO, Pascal VOC, YOLO, spaCy NER, CSV, and plain JSON via the label-studio-sdk converter library bundled in the package
• A REST API and Python SDK for programmatic project creation, task import, annotation retrieval, and export automation
• Docker and Docker Compose deployment with Nginx and PostgreSQL for production-ready self-hosting

Common Use Cases

• Computer vision dataset creation — teams upload image batches to S3, configure bounding box or polygon labeling interfaces, and export COCO JSON for object detection or segmentation model training
• NLP corpus annotation — NER, text classification, and sentiment labeling workflows where annotators highlight spans or select from taxonomies, then export spaCy or JSON format for fine-tuning language models
• Audio and speech data labeling — transcription, segment classification, and speaker diarization tasks where annotators draw timeline regions over waveforms and attach labels or text transcriptions
• Active learning pipelines — connecting an inference server as an ML backend, letting Label Studio surface the most uncertain predictions for human review, retraining the model after each labeling batch
• Video object tracking — frame-by-frame annotation of bounding boxes with keyframe interpolation for object detection and tracking dataset construction
• Time series anomaly labeling — annotating CSV or sensor data streams by drawing regions over irregular patterns for predictive maintenance or signal classification

Under The Hood

Architecture Label Studio is organized as a layered Django monolith with clean module boundaries: separate Django apps for projects, tasks, annotations, data import, data export, ML backends, io_storages, organizations, users, and a finite state machine layer called fsm that tracks annotation workflow states. The backend exposes a Django REST Framework API consumed by the React frontend. Dependency injection for enterprise customization is done through Django settings: every major model has a corresponding *_MIXIN setting (e.g., TASK_MIXIN, PROJECT_MIXIN, EXPORT_MIXIN) that loads a dotted Python path at startup, allowing Label Studio Enterprise to slot in additional behavior without modifying the community codebase. The FSM layer introduced in recent versions manages annotation lifecycle state transitions with caching backed by Redis in enterprise deployments and the default Django cache in community deployments.

Tech Stack The backend is Python 3.10+ on Django 5.1 with Django REST Framework, using PostgreSQL (recommended) or SQLite for storage. Async task processing uses Redis Queue (RQ) for deferred export jobs, ML backend polling, and storage sync operations. The frontend is a React 17/18 application using mobx-state-tree for state management, packaged in an Nx monorepo with Yarn and Webpack, organized into separate libraries: editor (the annotation canvas), datamanager (task browsing and filtering), app-common, and ui. The annotation canvas itself is a custom React+Canvas rendering engine supporting rich region types. Infrastructure is delivered as a multi-stage Docker build (Node 22 for frontend, Python 3.13 for backend, Nginx as reverse proxy). LaunchDarkly (offline/file mode) drives feature flags at the process level.

Code Quality The test suite is comprehensive, spanning pytest unit and integration tests for the Python backend (over 160 test files) and Tavern YAML-based API tests covering import, export, storage, and annotation flows. The codebase is typed—models use Django’s typed field system and recent additions use Python type annotations and Pydantic models for API validation. ESLint and Prettier enforce frontend code style; the backend uses Poetry for dependency management and includes a migration linter to catch unsafe schema changes before they reach production. CI uses GitHub Actions with separate build pipelines for frontend and backend, including Docker image testing. Error handling is explicit throughout: custom exception classes, Sentry integration for both frontend and backend, and typed REST Framework exceptions with meaningful HTTP status codes.

What Makes It Unique Label Studio’s distinguishing design decision is its declarative XML labeling configuration system. Rather than hard-coding labeling interfaces for specific data types, operators compose interfaces from XML tags—<Image>, <RectangleLabels>, <Audio>, <TimelineLabels>, <TextArea>, etc.—and Label Studio renders the appropriate annotation controls at runtime. This means a single tool handles bounding boxes, semantic segmentation bitmask brushes, NER spans, audio waveform regions, video keyframe labels, and time series annotations without deploying separate specialized tools for each modality. The ML backend protocol—a simple HTTP server implementing predict and train endpoints—combined with interactive annotation mode (where a model returns updated predictions as the annotator draws each stroke) enables human-in-the-loop workflows that are difficult to achieve with purpose-built labeling tools.

Self-Hosting

Label Studio is released under the Apache License 2.0, a permissive open-source license. You can use it commercially, modify the source code, and distribute it without triggering any copyleft obligations on your own codebase. The only requirements are preserving copyright notices and the license text. There is no usage-based restriction in the open-source edition—you can run it for any purpose, with any number of users and projects, without paying anyone.

Running Label Studio yourself means taking responsibility for a non-trivial Django application stack. A production deployment requires at minimum Python 3.10+, a PostgreSQL database, a Redis instance for async task queues, and an Nginx reverse proxy to serve frontend static assets. Cloud storage integrations (S3, GCS, Azure) require appropriate IAM credentials and network access from your host. You are responsible for database backups, software upgrades between releases (which ship roughly every 2-3 months), horizontal scaling of the Django workers if annotation volume warrants it, and monitoring application health. The Helm chart maintained by HumanSignal provides a Kubernetes deployment path, but tuning it for your traffic patterns and persistence requirements is your team’s responsibility.

HumanSignal’s commercial offering—Label Studio Enterprise—adds capabilities that matter at organizational scale: SSO via SAML/LDAP/SCIM, project-level role-based access control, team workspaces for isolating projects by department, analytics dashboards for annotator performance and label distribution, a review workflow with dedicated reviewer roles, and SLA-backed enterprise support. If your use case involves a large annotation team with compliance requirements around access control, or you need managed uptime guarantees and vendor support for troubleshooting, the Enterprise tier covers those gaps. The community edition is well-suited for engineering teams comfortable managing their own infrastructure who need a powerful, flexible labeling tool without a per-seat subscription.