| Format | Extensions      | Notes                    | Max Size |
| ------ | --------------- | ------------------------ | -------- |
| JPEG   | `.jpg`, `.jpeg` | Most common, recommended | 50 MB    |
| PNG    | `.png`          | Supports transparency    | 50 MB    |
| WebP   | `.webp`         | Modern, good compression | 50 MB    |
| BMP    | `.bmp`          | Uncompressed             | 50 MB    |
| TIFF   | `.tiff`, `.tif` | High quality             | 50 MB    |
| HEIC   | `.heic`         | iPhone photos            | 50 MB    |
| AVIF   | `.avif`         | Next-gen format          | 50 MB    |
| JP2    | `.jp2`          | JPEG 2000                | 50 MB    |
| DNG    | `.dng`          | Raw camera               | 50 MB    |
| MPO    | `.mpo`          | Multi-picture object     | 50 MB    |

Videos are automatically extracted to frames on the client side at 1 FPS (max 100 frames per video).

| Format | Extensions | Extraction            | Max Size |
| ------ | ---------- | --------------------- | -------- |
| MP4    | `.mp4`     | 1 FPS, max 100 frames | 1 GB     |
| WebM   | `.webm`    | 1 FPS, max 100 frames | 1 GB     |
| MOV    | `.mov`     | 1 FPS, max 100 frames | 1 GB     |
| AVI    | `.avi`     | 1 FPS, max 100 frames | 1 GB     |
| MKV    | `.mkv`     | 1 FPS, max 100 frames | 1 GB     |
| M4V    | `.m4v`     | 1 FPS, max 100 frames | 1 GB     |

!!! info "Video Frame Extraction"

    Video frames are extracted at 1 frame per second in the browser before upload. A 60-second video produces 60 frames. The maximum is 100 frames per video — for videos longer than ~100 seconds, 100 frames are evenly sampled across the full duration.

Archives are extracted and processed automatically.

| Format | Extensions              | Notes             | Free   | Pro    | Enterprise |
| ------ | ----------------------- | ----------------- | ------ | ------ | ---------- |
| ZIP    | `.zip`                  | Most common       | 10 GB  | 20 GB  | 50 GB      |
| TAR    | `.tar` `.tar.gz` `.tgz` | Compressed or raw | 10 GB  | 20 GB  | 50 GB      |
| NDJSON | `.ndjson`               | Dataset export    | 10 GB  | 20 GB  | 50 GB      |

Use the standard YOLO directory structure with a `data.yaml` file:

```
my-dataset/
├── images/
│   ├── train/
│   │   ├── img001.jpg
│   │   └── img002.jpg
│   └── val/
│       ├── img003.jpg
│       └── img004.jpg
├── labels/
│   ├── train/
│   │   ├── img001.txt
│   │   └── img002.txt
│   └── val/
│       ├── img003.txt
│       └── img004.txt
└── data.yaml
```

The YAML file defines your dataset configuration:

```yaml
# data.yaml
path: .
train: images/train
val: images/val

names:
    0: person
    1: car
    2: dog
```

Use JSON annotation files with the standard [COCO structure](https://cocodataset.org/#format-data):

```
my-coco-dataset/
├── train/
│   ├── _annotations.coco.json
│   ├── img001.jpg
│   └── img002.jpg
└── val/
    ├── _annotations.coco.json
    ├── img003.jpg
    └── img004.jpg
```

The JSON file contains `images`, `annotations`, and `categories` arrays:

```json
{
    "images": [{ "id": 1, "file_name": "img001.jpg", "width": 640, "height": 480 }],
    "annotations": [{ "id": 1, "image_id": 1, "category_id": 0, "bbox": [100, 50, 200, 300] }],
    "categories": [{ "id": 0, "name": "person" }]
}
```

COCO annotations are automatically converted during upload. Detection (`bbox`), segmentation (`segmentation` polygons), and pose (`keypoints`) tasks are supported. Category IDs are remapped to a dense 0-indexed sequence across all annotation files. For converting between formats, see [format conversion tools](../../datasets/detect/index.md#port-or-convert-label-formats).

Classification uploads are auto-detected from common folder layouts:

```
split/class/image.jpg
class/split/image.jpg
class/image.jpg
```

Example:

```
my-classify-dataset/
├── train/
│   ├── cats/
│   └── dogs/
└── val/
    ├── cats/
    └── dogs/
```

Ultralytics NDJSON exports can be uploaded directly back into Platform. This is useful for moving datasets between workspaces while preserving metadata, classes, splits, and annotations.

**Raw**: Upload unannotated images (no labels). Useful when you plan to annotate directly on the platform using the [annotation editor](annotation.md).

You can also upload images without explicit split folders. Platform respects the active split target during upload, and for non-classify datasets it may automatically create a validation split from part of the training set when no split information is provided. You can always reassign images later with bulk move-to-split or split redistribution.

The format is detected automatically: datasets with a `data.yaml` containing `names`, `train`, or `val` keys are treated as YOLO. Datasets with COCO JSON files (containing `images`, `annotations`, and `categories` arrays) are treated as COCO. `.ndjson` exports are imported as Ultralytics NDJSON. Datasets with only images and no annotations are treated as raw.

graph LR
    A[Upload] --> B[Validate]
    B --> C[Normalize]
    C --> D[Thumbnail]
    D --> E[Parse Labels]
    E --> F[Statistics]

    style A fill:#4CAF50,color:#fff
    style B fill:#2196F3,color:#fff
    style C fill:#2196F3,color:#fff
    style D fill:#2196F3,color:#fff
    style E fill:#2196F3,color:#fff
    style F fill:#9C27B0,color:#fff

You can validate your dataset locally before uploading:

```python
from ultralytics.data.utils import check_det_dataset

check_det_dataset("path/to/data.yaml")
```

Images must be at least 28px on their shortest side. Images smaller than this are rejected during processing. Images larger than 4096px on their longest side are automatically resized with aspect ratio preserved.

| Sort                 | Description                  |
| -------------------- | ---------------------------- |
| Newest / Oldest      | Upload / creation order      |
| Name A-Z / Z-A       | Filename alphabetical        |
| Height ↑/↓           | Image height in pixels       |
| Width ↑/↓            | Image width in pixels        |
| Size ↑/↓             | File size on disk            |
| Annotations ↑/↓      | Annotation count per image   |

!!! note "Large Datasets"

    For datasets over 100,000 images, name / size / width / height sorts are disabled to keep the gallery responsive. Newest, oldest, and annotation-count sorts remain available.

| Filter           | Options                             |
| ---------------- | ----------------------------------- |
| **Split filter** | Train, Val, Test, or All            |
| **Label filter** | All, Labeled, or Unlabeled          |
| **Class filter** | Filter by class name                |
| **Search**       | Filter images by filename           |

Use the label filter set to `Unlabeled` to quickly find images that still need annotation. This is especially useful for large datasets where you want to track labeling progress.

A chip above the chart shows how many points are selected — click the `×` to clear the lasso and return to the full gallery view.

If your dataset has class imbalance (e.g., 10,000 "person" annotations but only 50 "bicycle"), use the `Log Scale` toggle on the class histogram to visualize all classes clearly.

Statistics are cached for 5 minutes. Changes to annotations will be reflected after the cache expires.

Click the expand button on any heatmap to view it in fullscreen mode. This provides a larger, more detailed view — useful for understanding spatial patterns in large datasets.

| Error                      | Cause                                   | Fix                                    |
| -------------------------- | --------------------------------------- | -------------------------------------- |
| Unable to read image file  | Corrupted or unsupported format         | Re-export from image editor            |
| Incomplete or corrupted    | File was truncated during transfer      | Re-download the original file          |
| Image too small            | Minimum dimension below 28px            | Use higher resolution source images    |
| Unsupported color mode     | CMYK or indexed color mode              | Convert to RGB mode                    |

Version creation is available after the dataset reaches `ready` status.

Create a version before and after major changes to your dataset — adding images, fixing annotations, or rebalancing splits. This lets you compare model performance across different dataset states.

The size shown is the NDJSON export file size, which contains image URLs and annotations — not the images themselves. Actual image data is stored separately and accessed via signed URLs.

{"type": "dataset", "task": "detect", "name": "my-dataset", "description": "...", "url": "https://platform.ultralytics.com/...", "class_names": {"0": "person", "1": "car"}, "version": 1, "created_at": "2026-01-15T10:00:00Z", "updated_at": "2026-02-20T14:30:00Z"}
{"type": "image", "file": "img001.jpg", "url": "https://...", "width": 640, "height": 480, "split": "train", "annotations": {"boxes": [[0, 0.5, 0.5, 0.2, 0.3]]}}
{"type": "image", "file": "img002.jpg", "url": "https://...", "width": 1280, "height": 720, "split": "val"}

Image URLs in the exported NDJSON are signed and valid for 7 days. If you need fresh URLs, re-export the dataset or create a new version.

The image context menu operates on a **single image**. For bulk operations on multiple images, use **Table** view with checkbox selection.

Upload all images to one dataset, then use bulk move-to-split to organize subsets into train, validation, and test splits.

Click the **Auto** button to instantly set the recommended 80/20 train/validation split. This is the most common ratio for training.

ul://username/datasets/dataset-slug

```bash
export ULTRALYTICS_API_KEY="YOUR_API_KEY"
yolo train model=yolo26n.pt data=ul://username/datasets/my-dataset epochs=100
```

```python
from ultralytics import YOLO

model = YOLO("yolo26n.pt")
model.train(data="ul://username/datasets/my-dataset", epochs=100)
```

The `ul://` URI works from any environment:

- **Local machine**: Train on your hardware, data downloaded automatically
- **Google Colab**: Access your Platform datasets in notebooks
- **Remote servers**: Train on cloud VMs with full dataset access

When cloning a dataset with a copyleft license (AGPL-3.0, GPL-3.0, CC-BY-SA-4.0, CC-BY-NC-SA-4.0), the clone inherits the license and the license selector is locked.

Each image stores annotations for all task types together. Changing the dataset task type controls which annotations are visible in the editor and included in exports and training. Annotations for other task types are preserved in the database and reappear when you switch back.

Deleted datasets are moved to Trash — not permanently deleted. You can restore them within 30 days from [`Settings > Trash`](../account/trash.md).

graph LR
    A[Dataset] --> B[New Model]
    B --> C[Select Project]
    C --> D[Configure]
    D --> E[Start Training]

    style A fill:#2196F3,color:#fff
    style E fill:#4CAF50,color:#fff

One `.txt` file per image with normalized coordinates (0-1 range):

| Task     | Format                           | Example                             |
| -------- | -------------------------------- | ----------------------------------- |
| Detect   | `class cx cy w h`                | `0 0.5 0.5 0.2 0.3`                 |
| Segment  | `class x1 y1 x2 y2 ...`          | `0 0.1 0.1 0.9 0.1 0.9 0.9`         |
| Pose     | `class cx cy w h kx1 ky1 v1 ...` | `0 0.5 0.5 0.2 0.3 0.6 0.7 2`       |
| OBB      | `class x1 y1 x2 y2 x3 y3 x4 y4`  | `0 0.1 0.1 0.9 0.1 0.9 0.9 0.1 0.9` |
| Classify | Directory structure              | `train/cats/`, `train/dogs/`        |

Pose visibility flags: 0=not labeled, 1=labeled but occluded, 2=labeled and visible.

JSON files with `images`, `annotations`, and `categories` arrays. Supports detection (`bbox`), segmentation (polygon), and pose (`keypoints`) tasks. COCO uses absolute pixel coordinates which are automatically converted to normalized format during upload.

Ultralytics NDJSON exports can be re-imported into Platform. This is the most complete way to move dataset metadata, splits, and annotations between workspaces.