Skip to main content

Label Studio: Data Labeling, Annotation & ML Integration

Label Studio is the open-source data labeling platform that handles text, images, audio, and video in one tool. Build training datasets with ML-assisted pre-annotation, export to COCO/YOLO/CoNLL, and close the active learning loop — all self-hosted.

✓ Text / image / audio / video ✓ ML-assisted pre-annotation ✓ COCO / YOLO / CoNLL export ✓ Fully self-hostable (Apache 2.0)
Share this tool: X / Twitter LinkedIn
✓ 60,000+ developers use DevPlaybook ★★★★★ 4.8 / 5 on Gumroad ✓ MIT licensed · Instant download ✓ No login required

Related Products

on Gumroad

You Might Also Need

More Free Tools

Enjoying this tool? Get more like it.

Weekly developer tool guides, productivity playbooks & AI tricks. Free. No spam.

DevPlaybook Pro 7 days free

Unlock AI-Powered Dev Tools

  • ⚡ AI Code Review, Doc Generator & SQL Builder
  • ⚡ All premium templates & early access
  • ⚡ Member discounts on Gumroad products
Start Free Trial →

$9/mo after trial · Cancel anytime

Want the full toolkit?

Get DevPlaybook Pro

Every template, guide, boilerplate, and automation script in one bundle. 13 premium products — grab them all at once and save big.

$79
$241 separately Save $162 (67% off)
Get DevPlaybook Pro — $79 →

MIT licensed · Instant download · No subscription

See what's included → Browse all deals →

Setup & Project Configuration

Run Label Studio locally or via Docker, then configure labeling projects with XML templates:

# Install and run (local)
pip install label-studio
label-studio start         # opens http://localhost:8080

# Or Docker
docker run -it -p 8080:8080 \
  -v $(pwd)/mydata:/label-studio/data \
  -e LABEL_STUDIO_LOCAL_FILES_SERVING_ENABLED=true \
  heartexlabs/label-studio:latest

# Create a project via Python SDK
from label_studio_sdk import Client

ls = Client(url="http://localhost:8080", api_key="your-api-key")
project = ls.create_project(
    title="Product Image Classification",
    label_config="""
<View>
  <Image name="image" value="$image"/>
  <Choices name="category" toName="image" choice="single">
    <Choice value="Electronics"/>
    <Choice value="Clothing"/>
    <Choice value="Furniture"/>
    <Choice value="Food"/>
  </Choices>
</View>
    """
)

# Import tasks (URLs or local files)
project.import_tasks([
    {"image": "https://example.com/img1.jpg"},
    {"image": "https://example.com/img2.jpg"},
])

NER & Bounding Box Labeling Configs

Label Studio uses XML-based configs to define labeling interfaces for any task type:

<!-- Named Entity Recognition (NER) config -->
<View>
  <Labels name="label" toName="text">
    <Label value="PERSON" background="blue"/>
    <Label value="ORGANIZATION" background="green"/>
    <Label value="LOCATION" background="orange"/>
    <Label value="DATE" background="purple"/>
    <Label value="MONEY" background="red"/>
  </Labels>
  <Text name="text" value="$text"/>
</View>

<!-- Object Detection (bounding box) config -->
<View>
  <RectangleLabels name="label" toName="image">
    <Label value="Car" background="#FF0000"/>
    <Label value="Person" background="#00FF00"/>
    <Label value="Bicycle" background="#0000FF"/>
  </RectangleLabels>
  <Image name="image" value="$image" zoom="true" zoomControl="true"/>
</View>

<!-- Polygon segmentation config -->
<View>
  <PolygonLabels name="label" toName="image" strokeWidth="3">
    <Label value="Road" background="#808080"/>
    <Label value="Building" background="#A0522D"/>
    <Label value="Vegetation" background="#228B22"/>
  </PolygonLabels>
  <Image name="image" value="$image"/>
</View>

ML-Assisted Labeling with Active Learning

Connect a prediction server to pre-annotate tasks and close the active learning loop:

# label_studio_ml backend (FastAPI-based prediction server)
from label_studio_ml.model import LabelStudioMLBase

class NERPredictor(LabelStudioMLBase):
    def __init__(self, **kwargs):
        super().__init__(**kwargs)
        import spacy
        self.nlp = spacy.load("en_core_web_lg")

    def predict(self, tasks, **kwargs):
        predictions = []
        for task in tasks:
            text = task["data"]["text"]
            doc = self.nlp(text)
            results = []
            for ent in doc.ents:
                results.append({
                    "from_name": "label",
                    "to_name": "text",
                    "type": "labels",
                    "value": {
                        "start": ent.start_char,
                        "end": ent.end_char,
                        "text": ent.text,
                        "labels": [ent.label_],
                    },
                    "score": 0.9,
                })
            predictions.append({"result": results, "score": 0.9})
        return predictions

# Run: label-studio-ml start . --port 9090
# Connect in Label Studio: Settings → ML → Add ML Backend → http://localhost:9090

Label Studio vs Scale AI vs V7 vs CVAT

Feature Label Studio Scale AI V7 Darwin CVAT
Open-sourceYes (Apache 2.0)No (SaaS)No (SaaS)Yes (MIT)
Data typesAll (text/img/audio/video)All + 3D LiDARImages/videoImages/video
ML-assisted labelingML backend APIAuto-annotationAuto-annotateSemi-auto
Human workforceNo (your team)Scale workforceLimitedNo
Self-hostableYes (Docker)NoEnterprise onlyYes (Docker)
Export formatsCOCO/YOLO/CoNLL/VOC/JSONJSON/CSVCOCO/Pascal VOCCOCO/VOC/YOLO
Best forSelf-hosted, multi-modalEnterprise, large scaleCV teams, SaaSCV tasks, free

Frequently Asked Questions

What is Label Studio and what data types does it support?▼

Label Studio is an open-source data labeling platform that supports a wide range of data types: text (NER, classification, span labeling), images (bounding boxes, polygons, semantic segmentation, keypoints), audio (transcription, classification, speaker diarization), video (object tracking, temporal classification), time series, and HTML/conversational data. A single instance can label all these types with different labeling interfaces configured per project.

How does ML-assisted labeling work in Label Studio?▼

Label Studio's ML backend integration lets a trained model pre-annotate incoming data. You connect a prediction server (your own FastAPI endpoint or a Label Studio ML backend template) that receives task data and returns pre-filled annotations. Annotators then review and correct the predictions instead of labeling from scratch, reducing labeling time by 60-80% for tasks where your model has reasonable accuracy. The corrected labels feed back to retrain the model (active learning loop).

What export formats does Label Studio support?▼

Label Studio exports to: JSON (native), COCO (object detection), YOLO (darknet format), Pascal VOC XML, CSV, TSV, CoNLL (NER), and custom templates via Python SDK exporters. For HuggingFace datasets, use the label-studio-sdk to export directly to the datasets format. For custom formats, write a converter using the label-studio-converter library.

Can Label Studio be self-hosted?▼

Yes, Label Studio is fully open-source (Apache 2.0) and runs as a Docker container or Python package. Self-host with docker run -it -p 8080:8080 heartexlabs/label-studio:latest. Data stays on your infrastructure — critical for medical, legal, or PII data. Label Studio Enterprise adds SSO, RBAC, advanced QA workflows, and cloud storage auto-sync, but the open-source version is fully functional for most teams.

How do I set up an NER (Named Entity Recognition) labeling project?▼

In Label Studio, create a project and select the NER template. The labeling config is XML-based: define Labels (entity types like PERSON, ORG, DATE) and bind them to a Text view. Annotators highlight text spans and tag them. Export as CoNLL or JSON for training spaCy, HuggingFace NER models, or custom models. Use pre-annotations from an existing NER model to speed up the process.

How does Label Studio handle annotation quality control?▼

Label Studio supports inter-annotator agreement (IAA) scoring, annotation review workflows (submit → review → accept/reject), and task overlap (assign the same task to multiple annotators and compute agreement). In Label Studio Enterprise, automated QA rules can flag low-confidence annotations. For open-source, use the Python SDK to compute Cohen's kappa or Krippendorff's alpha on exported annotations.