If you already have datasets in [Roboflow](../integrations/roboflow.md), use [Integrations](../integrations/index.md) to import them directly — no manual export or re-upload needed. Data in [Google Cloud Storage](../integrations/google-cloud-storage.md), [Amazon S3](../integrations/amazon-s3.md), or [Azure Blob Storage](../integrations/azure-blob-storage.md) can be used in place through **Cloud storage**. Enterprise workspaces can use [On Premise](../integrations/on-premise.md) to index and train on local data without sending pixels to Platform.

| 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    |

During processing, Platform samples video frames at 1 FPS — up to 100 frames per video — and stores each frame as a WebP image named `<video>_frame_001.webp`. For longer videos, the sampling interval widens so the result stays within 100 frames. The container and codec must be decodable by Platform — see [Video Codec Support](#video-codec-support).

| 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     |
| MKV    | `.mkv`     | 1 FPS, max 100 frames | 1 GB     |
| M4V    | `.m4v`     | 1 FPS, max 100 frames | 1 GB     |

!!! info "Video Frame Extraction"

    A 60-second video produces up to 60 WebP frames. For videos longer than 100 seconds, frames are sampled at a wider interval so the result stays within 100 frames.

AVI is not accepted and is excluded from the upload picker. Re-wrap AVI footage as MP4 before uploading.

Archives are extracted and processed automatically. Archives can also be nested inside a folder structure, and a single archive can mix images, videos, and labels.

| 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      |

Password-protected (encrypted) archives are rejected — re-create the archive without a password.

H.264 video in an MP4 container has the broadest decoder support and is the safest choice. If a video won't process, re-encode it with [FFmpeg](https://ffmpeg.org/):

```bash
ffmpeg -i input.mov \
  -c:v libx264 -pix_fmt yuv420p \
  -c:a aac -movflags +faststart \
  output.mp4
```

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

```text
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):

```text
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:

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

Example:

```text
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. If no split target is set and the upload leaves the `val` split empty, non-classify datasets automatically move roughly 20% of the `train` images to `val` so the dataset is immediately trainable. Classification datasets are skipped because they use directory-based splits. You can always reassign images later with [bulk move-to-split](#bulk-move-to-split) or [split redistribution](#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.

When an archive contains several YAML files, Platform prefers standard names (`data.yaml`, `data.yml`, `dataset.yaml`, `dataset.yml`) closest to the archive root. Keep one clearly named YAML per archive to avoid ambiguity.

Label files in Pascal VOC XML format are detected but their annotations are **not** imported — the images upload as unannotated. Platform warns you before the upload starts ("Pascal VOC labels detected"). Convert VOC XML to YOLO or COCO first; see [format conversion tools](../../datasets/detect/index.md#port-or-convert-label-formats).

A URL import is capped by both your plan's per-upload limit (10 GB Free / 20 GB Pro / 50 GB Enterprise) and your remaining storage quota, whichever is smaller. The link must be publicly reachable over HTTP or HTTPS and end in a supported extension.

When the archive declares class names and your dataset already has classes, the `Map imported classes` dialog lists one row per incoming class. For each one, choose an existing class to merge into, create a new class, or skip it. Exact name matches are preselected, and skipped classes and their annotations are not imported.

When you upload an archive, multiple files, or anything into a dataset that already has images, Platform asks how to handle filename or content conflicts:

| Choice        | Behavior                                    |
| ------------- | ------------------------------------------- |
| **Skip**      | Keep the existing images, drop the incoming |
| **Keep Both** | Import the incoming alongside the existing  |
| **Replace**   | Overwrite the existing images               |

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

    classDef start fill:#4CAF50,color:#fff
    classDef proc fill:#2196F3,color:#fff
    classDef out fill:#9C27B0,color:#fff

AVIF and WebP originals are stored byte-for-byte when no resize or color change is needed. Everything else is re-encoded — WebP sources stay WebP, and all other formats (JPEG, PNG, BMP, TIFF, HEIC, JP2, DNG, MPO) become JPEG at quality 92. Your original filename and source extension are retained as metadata.

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.

Each option toggles between ascending (↑) and descending (↓):

| Sort            | Description                |
| --------------- | -------------------------- |
| Created ↑/↓     | Upload order (default ↓)   |
| Name ↑/↓        | 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, the name, width, height, and size sorts are hidden to keep the gallery responsive. Created and annotation-count sorts remain available.

| Filter           | Options                               |
| ---------------- | ------------------------------------- |
| **Split filter** | Train, Val, Test, or All              |
| **Annotations**  | All images, Annotated, or Unannotated |
| **Class filter** | Filter by class name                  |
| **Search**       | Filter images by filename or metadata |

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

The search box sits at the right of the gallery toolbar and filters every view mode — grid, compact, and table. It matches the image filename (the file extension is optional) as well as custom metadata keys, scalar values, and array entries, so an image named `img_0042` carrying `{"ship_type": "yacht"}` is found by searching either `img_0042` or `yacht`.

Values nested inside sub-objects are not matched. Pasting a 24-character image ID looks up that exact image
directly, bypassing the text search.

A dataset needs at least 20 and at most 200,000 non-errored images to analyze. [Connected datasets](../integrations/index.md) backed by cloud or On Premise storage are not supported yet.

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

A lasso resolves to at most 1,000 images. If your selection matches more, Platform shows a sampled 1,000 and suggests drawing a smaller region.

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.

Class IDs are positional. Merging or deleting a class shifts every higher class index down to close the gap, so exports and label files written before the change no longer line up with the new indices. Create a [version](#versions-tab) first if you need the old numbering.

Class counts are computed from at most 100,000 images. On larger datasets a note above the histogram reads "Based on a 100,000-image subset of this dataset."

The Platform caches computed statistics and invalidates them when images, annotations, classes, or splits change. On datasets larger than 100,000 images the charts are computed from a 100,000-image subset, noted above the grid.

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       |
| Unsupported image format  | Format Platform cannot decode      | Convert to JPG, PNG, or WebP        |
| File permission error     | File is locked or read-protected   | Unlock the file and re-upload       |
| Image too small           | Minimum dimension below 28px       | Use higher resolution source images |
| Unsupported color mode    | CMYK or indexed color mode         | Convert to RGB mode                 |

Restore replaces the dataset's current images, splits, classes, and annotations with the selected snapshot and cannot be undone unless you first save the current state as another version. The dataset is locked in `processing` status while it rebuilds. Nothing is re-uploaded during a restore, so restores are typically fast even on large datasets.

Enable **Save Dataset Version** in the [Cloud Training dialog](../train/cloud-training.md#save-dataset-version-optional) to link a model to the exact dataset used for training. The Platform reuses a matching version when the dataset contents have not changed and creates a new version only when they have.

Version creation and restore are available after the dataset reaches `ready` status. Versions are not available for [connected](../integrations/index.md) cloud or [On Premise](../integrations/on-premise.md) datasets.

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. The snapshot file still counts against your workspace [storage quota](../account/billing.md), so version creation fails if you have no headroom left.

{"type": "dataset", "task": "detect", "name": "my-dataset", "description": "...", "bytes": 12345678, "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", "metadata": {"location": {"site": "factory-1"}, "reviewed": true}, "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. Platform reuses a cached export for up to 6 days when the dataset has not changed, so a fresh download always has at least a day of validity left. If you need new URLs sooner, change the dataset or create a new version.

Export is not available for [On Premise](../integrations/on-premise.md) datasets, whose image bytes never reach Platform.

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-3.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.

Datasets backed by [cloud storage](../integrations/index.md) or [On Premise](../integrations/on-premise.md) sources cannot be cloned, because Platform does not hold their image bytes.

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]:::start --> B[New Model]:::proc
    B --> C[Select Project]:::proc
    C --> D[Configure]:::proc
    D --> E[Start Training]:::out

    classDef start fill:#4CAF50,color:#fff
    classDef proc fill:#2196F3,color:#fff
    classDef out fill:#9C27B0,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.