=== "cURL"

    ```bash
    # List the datasets owned by a workspace
    curl -H "Authorization: Bearer YOUR_API_KEY" \
      https://platform.ultralytics.com/api/datasets/YOUR_USERNAME
    ```

=== "Python SDK"

    ```bash
    pip install "ultralytics-platform>=0.1.5" # Python 3.11+
    ```

    ```python
    from ultralytics_platform import Platform

    client = Platform(api_key="YOUR_API_KEY")
    datasets = client.datasets.list("YOUR_USERNAME")
    ```

Every endpoint below lists its `client.<resource>.<method>(...)` call from the
[`ultralytics-platform`](https://pypi.org/project/ultralytics-platform/) SDK, which is generated from the same
contract as this reference.

This page is a guided tour of the API. The generated, always-current reference lives at
[platform.ultralytics.com/api/docs](https://platform.ultralytics.com/api/docs), and the machine-readable OpenAPI 3.2
document that powers it is published at
[platform.ultralytics.com/openapi.json](https://platform.ultralytics.com/openapi.json). Both are generated directly
from the server-side contract, so they are the authority whenever this page and the schema disagree.

graph LR
    A[API Key]:::start --> B[Datasets]:::proc
    A --> C[Projects]:::proc
    B -->|images| G[Images]:::proc
    C -->|contains| D[Models]:::proc
    B -->|train on| D
    D -->|deploy| E[Deployments]:::proc
    D -->|export| F[Exports]:::proc

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

Authorization: Bearer YOUR_API_KEY

API keys are the literal prefix `ul_` followed by 40 hexadecimal characters, 43 characters in total (for example
`ul_a1b2c3d4e5f6789012345678901234567890abcd`). Requests with a missing header, a malformed key, or a revoked key
return `401`. Keep your key secret -- never commit it to version control or share it publicly.

```bash
curl -H "Authorization: Bearer YOUR_API_KEY" \
  https://platform.ultralytics.com/api/account/summary
```

```python
from ultralytics_platform import Platform

client = Platform(api_key="YOUR_API_KEY")  # or set ULTRALYTICS_API_KEY
account = client.account.summary()
print(account["username"], account["plan"], account["creditsCents"])
```

```javascript
const response = await fetch("https://platform.ultralytics.com/api/account/summary", {
  headers: { Authorization: "Bearer YOUR_API_KEY" },
});
const account = await response.json();
```

https://platform.ultralytics.com/api

There is no `owner` query parameter. Workspace-scoped paths carry the owner in the path, and account-scoped
endpoints (`/api/account/summary`, `/api/api-keys`, `/api/storage`, `/api/billing/*`, `/api/trash`,
`/api/integrations/buckets`) operate on the workspace that issued the API key. To act on a team workspace, use an
API key created in that workspace.

Retry-After: 12
X-RateLimit-Reset: 2026-02-21T12:34:56.000Z

{
    "error": "Rate limit exceeded",
    "retryAfter": 12,
    "resetAt": "2026-02-21T12:34:56.000Z"
}

When you receive a `429`, wait for `Retry-After` seconds (or until `X-RateLimit-Reset`) before retrying. See the
[rate limit FAQ](#how-do-i-handle-rate-limits) for an exponential backoff implementation.

{
    "datasets": [{ "id": "65f1c0a2b3d4e5f601234567", "owner": "acme-vision", "dataset": "warehouse" }],
    "total": 1,
    "region": "us"
}

{
    "error": "Dataset not found"
}

GET /api/datasets/{owner}

```bash
curl -H "Authorization: Bearer YOUR_API_KEY" \
  "https://platform.ultralytics.com/api/datasets/acme-vision?limit=10&includeSamples=false"
```

```python
from ultralytics_platform import Platform

client = Platform()  # reads ULTRALYTICS_API_KEY
for ds in client.datasets.list("acme-vision", limit=10, include_samples="false")["datasets"]:
    print(f"{ds['dataset']}: {ds['imageCount']} images, task={ds['task']}")
```

{
    "datasets": [
        {
            "id": "65f1c0a2b3d4e5f601234567",
            "owner": "acme-vision",
            "dataset": "warehouse",
            "name": "Warehouse",
            "task": "detect",
            "visibility": "private",
            "imageCount": 1000,
            "classCount": 2,
            "classNames": ["person", "forklift"],
            "splits": { "train": 800, "val": 200, "test": 0, "labeled": 1000 },
            "annotationCount": 5400,
            "starCount": 3,
            "isStarred": false,
            "status": "ready",
            "createdAt": "2026-01-15T10:00:00Z",
            "updatedAt": "2026-01-16T08:30:00Z"
        }
    ],
    "total": 1,
    "region": "us"
}

GET /api/datasets/{owner}/{dataset}

POST /api/datasets

{
    "dataset": "warehouse",
    "name": "Warehouse",
    "task": "detect",
    "description": "Forklift and pedestrian safety dataset",
    "classNames": ["person", "forklift"],
    "visibility": "private",
    "metadata": { "location": "factory-1", "reviewed": true },
    "owner": "acme-vision"
}

Valid `task` values when creating or updating a dataset: `detect`, `segment`, `semantic`, `classify`, `pose`, and
`obb`. Depth datasets are not yet accepted by these routes, although `depth` is a valid model and project task.

{
    "id": "65f1c0a2b3d4e5f601234567",
    "owner": "acme-vision",
    "dataset": "warehouse",
    "region": "us"
}

PATCH /api/datasets/{owner}/{dataset}

{
    "name": "Warehouse Safety",
    "description": "New description",
    "visibility": "public",
    "metadata": { "location": "factory-2", "reviewed": true }
}

{
    "success": true,
    "dataset": "warehouse-safety"
}

DELETE /api/datasets/{owner}/{dataset}

POST /api/datasets/{owner}/{dataset}/clone

{
    "dataset": "warehouse-copy",
    "name": "Warehouse Copy",
    "description": "Cloned for experimentation",
    "visibility": "private",
    "license": "CC-BY-4.0",
    "owner": "acme-vision"
}

GET /api/datasets/{owner}/{dataset}/export

{
    "downloadUrl": "https://storage.googleapis.com/...&signature=...",
    "cached": true
}

POST /api/datasets/{owner}/{dataset}/export

{
    "description": "Added 500 training images"
}

{
    "version": 3,
    "downloadUrl": "https://storage.googleapis.com/...&signature=...",
    "reused": false
}

PATCH /api/datasets/{owner}/{dataset}/export

{
    "version": 2,
    "description": "Fixed mislabeled classes"
}

POST /api/datasets/{owner}/{dataset}/restore

{
    "version": 2
}

GET /api/datasets/{owner}/{dataset}/class-stats

{
    "classes": [{ "classId": 0, "count": 1500, "imageCount": 450 }],
    "imageStats": {
        "widthHistogram": [{ "bin": 640, "count": 120, "size": 1 }],
        "heightHistogram": [{ "bin": 480, "count": 95, "size": 1 }],
        "pointsHistogram": [{ "bin": 4, "count": 200, "size": 1 }],
        "formatDistribution": { "jpg": 900, "png": 100 },
        "fileSizeHistogram": [{ "bin": 250000, "count": 300, "size": 50000 }],
        "objectsPerImageHistogram": [{ "bin": 5, "count": 210, "size": 1 }],
        "bboxWidthHistogram": [{ "bin": 120, "count": 340, "size": 20 }],
        "bboxHeightHistogram": [{ "bin": 90, "count": 300, "size": 20 }]
    },
    "locationHeatmap": {
        "bins": [
            [5, 10],
            [8, 3]
        ],
        "maxCount": 50
    },
    "dimensionHeatmap": {
        "bins": [
            [2, 5],
            [3, 1]
        ],
        "maxCount": 12,
        "minWidth": 10,
        "maxWidth": 1920,
        "minHeight": 10,
        "maxHeight": 1080
    },
    "classNames": ["person", "forklift"],
    "cached": true,
    "sampleSize": null
}

POST /api/datasets/{owner}/{dataset}/classes/merge

{
    "sourceClassIds": [2, 4],
    "targetClassId": 1
}

POST /api/datasets/{owner}/{dataset}/classes/delete

{
    "classIds": [2, 4]
}

Because remaining IDs shift after a merge or delete, these operations are not idempotent. Re-fetch the dataset to
get current class indices before issuing another class operation.

POST /api/datasets/{owner}/{dataset}/splits/redistribute

{
    "train": 80,
    "val": 20,
    "test": 0
}

GET /api/datasets/{owner}/{dataset}/embeddings
POST /api/datasets/{owner}/{dataset}/embeddings
DELETE /api/datasets/{owner}/{dataset}/embeddings

GET /api/datasets/{owner}/{dataset}/images/clustering

GET /api/datasets/{owner}/{dataset}/models

{
    "models": [
        {
            "id": "65f1c0a2b3d4e5f601234599",
            "owner": "acme-vision",
            "project": "inspection",
            "model": "v3",
            "name": "v3",
            "status": "completed",
            "task": "detect",
            "epochs": 100,
            "bestEpoch": 87,
            "metrics": { "mAP50": 0.85, "mAP50-95": 0.72, "precision": 0.88, "recall": 0.81 },
            "startedAt": "2026-01-14T22:00:00Z",
            "completedAt": "2026-01-15T10:00:00Z",
            "createdAt": "2026-01-14T21:55:00Z"
        }
    ],
    "count": 1
}

GET /api/datasets/{owner}/{dataset}/images

{
    "images": [
        {
            "id": "65f1c0a2b3d4e5f601234567",
            "hash": "9f2c1d4b6a8e0f3c5d7b9a1e2f4c6d8b",
            "ext": "jpg",
            "name": "aisle-04.jpg",
            "thumbnailUrl": "https://storage.googleapis.com/...&signature=...",
            "width": 1920,
            "height": 1080,
            "split": "train",
            "labelCount": 6,
            "bytes": 284213,
            "error": null
        }
    ],
    "total": 1000,
    "hasMore": true,
    "classes": ["person", "forklift"],
    "errorCount": 0,
    "nextCursor": "65f1c0a2b3d4e5f601234567"
}

POST /api/datasets/{owner}/{dataset}/images

{
    "imageIds": ["65f1c0a2b3d4e5f601234567", "65f1c0a2b3d4e5f601234568"]
}

POST /api/datasets/{owner}/{dataset}/ingest

{
    "sessionId": "session_abc123",
    "targetSplit": "train"
}

{
    "sourceUrl": "https://example.com/my-dataset.zip"
}

{
    "sessionId": "session_abc123",
    "classMapping": { "person": 0, "automobile": "forklift", "background": null }
}

{
    "sessionId": "session_abc123",
    "imageMetadata": {
        "airbus-wing.jpg": { "aircraft": { "family": "A350" }, "inspectionStatus": "reviewed" },
        "images/tail.jpg": { "aircraft": { "family": "A320" }, "inspectionSeverity": 2 }
    }
}

The first ingest creates classes from the archive automatically. On later ingests, archive classes omitted from
`classMapping` fall back to a case-insensitive match against existing dataset classes. Labels are skipped only for
classes explicitly mapped to `null` or without a matching existing class.

{
    "jobId": "65f1c0a2b3d4e5f6012345aa",
    "status": "queued"
}

graph LR
    A[POST /api/datasets]:::start --> B[POST /api/upload/signed-url]:::proc
    B --> C[PUT archive to signed URL]:::proc
    C --> D[POST /api/upload/complete]:::proc
    D --> E["POST /api/datasets/{owner}/{dataset}/ingest"]:::proc
    E --> F[Process archive]:::proc
    F --> G[Dataset ready]:::out

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

The same code handles a group of images: add more files to the ZIP and matching entries to `imageMetadata`.

```python
import io
import zipfile
from pathlib import Path

import requests

api = "https://platform.ultralytics.com/api"
headers = {"Authorization": "Bearer YOUR_API_KEY"}
owner, dataset = "acme-vision", "warehouse"
dataset_id = "65f1c0a2b3d4e5f601234567"  # id returned by POST /api/datasets
image_path = Path("airbus-wing.jpg")

archive = io.BytesIO()
with zipfile.ZipFile(archive, "w", zipfile.ZIP_DEFLATED) as zf:
    zf.write(image_path, image_path.name)
data = archive.getvalue()

signed = requests.post(
    f"{api}/upload/signed-url",
    headers=headers,
    json={
        "assetType": "datasets",
        "assetId": dataset_id,
        "filename": "images.zip",
        "contentType": "application/zip",
        "totalBytes": len(data),
    },
)
signed.raise_for_status()
upload = signed.json()

requests.put(upload["uploadUrl"], headers={"Content-Type": "application/zip"}, data=data).raise_for_status()
requests.post(
    f"{api}/upload/complete",
    headers=headers,
    json={"sessionId": upload["sessionId"]},
).raise_for_status()

ingest = requests.post(
    f"{api}/datasets/{owner}/{dataset}/ingest",
    headers=headers,
    json={
        "sessionId": upload["sessionId"],
        "imageMetadata": {
            "airbus-wing.jpg": {
                "aircraft": {"family": "A350", "section": "wing"},
                "inspectionStatus": "reviewed",
            }
        },
    },
)
ingest.raise_for_status()
print(ingest.json())
```

GET /api/images/{imageId}

PATCH /api/images/{imageId}

{
    "labels": [
        { "classId": 0, "bbox": [0.5, 0.5, 0.2, 0.3] },
        { "classId": 1, "segments": [0.1, 0.2, 0.3, 0.2, 0.2, 0.4] }
    ]
}

{
    "metadata": { "location": "strasbourg", "reviewed": true }
}

Label coordinates use YOLO normalized values between 0 and 1. Bounding boxes use
`[x_center, y_center, width, height]`. Segmentation labels use `segments`, a flattened list of polygon vertices
`[x1, y1, x2, y2, ...]`. Pose labels use `keypoints` in one consistent flat shape: pairs `[x1, y1, x2, y2, ...]` or
triples `[x1, y1, v1, x2, y2, v2, ...]`, where visibility conventionally uses 0, 1, or 2. Oriented boxes use `obb`
corners. Saved coordinates are rounded to 5 decimal places, and an image accepts at most 10,000 annotations.

DELETE /api/images/{imageId}

POST /api/images/{imageId}/predict

PATCH /api/images/bulk

{
    "imageIds": ["65f1c0a2b3d4e5f601234567"],
    "split": "val",
    "conflictPolicy": "skip"
}

DELETE /api/images/bulk

{
    "imageIds": ["65f1c0a2b3d4e5f601234567", "65f1c0a2b3d4e5f601234568"]
}

POST /api/images/urls

{
    "imageIds": ["65f1c0a2b3d4e5f601234567"]
}

GET /api/projects/{owner}

GET /api/projects/{owner}/{project}

POST /api/projects

```bash
curl -X POST \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "project": "inspection",
    "name": "Inspection",
    "description": "Detection experiments",
    "metadata": {"department": "manufacturing", "cost_center": "cv-01"}
  }' \
  https://platform.ultralytics.com/api/projects
```

```python
created = client.projects.create(
    project="inspection",
    name="Inspection",
    description="Detection experiments",
    metadata={"department": "manufacturing", "cost_center": "cv-01"},
)
owner, project = created["owner"], created["project"]
```

PATCH /api/projects/{owner}/{project}

{
    "metadata": { "department": "research", "program": "inspection" }
}

DELETE /api/projects/{owner}/{project}

POST /api/projects/{owner}/{project}/clone

GET /api/models/{owner}/{project}

GET /api/models/{owner}/{project}/{model}

POST /api/models

To attach `.pt` weights, request a signed upload URL with `assetType: "models"` and this model's `id` as `assetId`,
`PUT` the file to the returned URL, then call `POST /api/upload/complete` with the returned `sessionId`.

PATCH /api/models/{owner}/{project}/{model}

{
    "metadata": { "release": "candidate-3", "reviewed": true }
}

DELETE /api/models/{owner}/{project}/{model}

GET /api/models/{owner}/{project}/{model}/files

{
    "files": [
        {
            "name": "best.pt",
            "size": 6534127,
            "downloadUrl": "https://storage.googleapis.com/...&signature=..."
        }
    ]
}

POST /api/models/{owner}/{project}/{model}/clone

{
    "owner": "acme-vision",
    "project": "inspection",
    "model": "v3-copy",
    "name": "V3 Copy",
    "description": "Cloned from a public model"
}

POST /api/models/{owner}/{project}/{model}/predict

```bash
curl -X POST \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -F "[email protected]" \
  -F "conf=0.5" \
  https://platform.ultralytics.com/api/models/acme-vision/inspection/v3/predict
```

```python
with open("image.jpg", "rb") as f:
    resp = client.models.predict("acme-vision", "inspection", "v3", body={"file": f, "conf": 0.5})
results = resp["images"][0]["results"]
```

{
    "images": [
        {
            "shape": [1080, 1920],
            "speed": { "preprocess": 2.1, "inference": 12.4, "postprocess": 1.3 },
            "results": [
                {
                    "class": 0,
                    "name": "person",
                    "confidence": 0.92,
                    "box": { "x1": 100, "y1": 50, "x2": 300, "y2": 400 }
                }
            ]
        }
    ],
    "metadata": {
        "imageCount": 1,
        "functionTimeAlive": 184.2,
        "functionTimeCall": 0.31,
        "task": "detect",
        "version": { "ultralytics": "8.4.120" }
    }
}

GET /api/models/{owner}/{project}/{model}/training

DELETE /api/models/{owner}/{project}/{model}/training

graph LR
    A[POST /api/training/start]:::start --> B[Job Created]:::proc
    B --> C{Training}:::decide
    C -->|progress| D[GET .../training]:::proc
    C -->|cancel| E[DELETE .../training]:::error
    C -->|complete| F[Model Ready]:::out
    F --> G[Deploy or Export]:::proc

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

GET /api/training/gpu-availability

POST /api/training/start

```bash
curl -X POST \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "modelId": "65f1c0a2b3d4e5f601234599",
    "gpuType": "rtx-4090",
    "trainArgs": {
      "model": "yolo26n.pt",
      "data": "ul://acme-vision/datasets/warehouse",
      "epochs": 100,
      "imgsz": 640,
      "batch": 16
    }
  }' \
  https://platform.ultralytics.com/api/training/start
```

```python
resp = client.training.start(
    model_id="65f1c0a2b3d4e5f601234599",
    gpu_type="rtx-4090",
    train_args={
        "model": "yolo26n.pt",
        "data": "ul://acme-vision/datasets/warehouse",
        "epochs": 100,
        "imgsz": 640,
        "batch": 16,
    },
)
print(resp["billing"]["estimatedCostDisplay"])
```

{
    "modelId": "65f1c0a2b3d4e5f601234599",
    "status": "starting",
    "gpuType": "rtx-4090",
    "estimatedCost": { "pricePerHour": 0.69, "gpuMemoryGb": 24 },
    "billing": {
        "estimatedCostCents": 138,
        "estimatedCostDisplay": "$1.38",
        "balanceCents": 2500
    }
}

26 GPU types are available, from `rtx-2000-ada` through `b300`, including `rtx-4090`, `l40s`, `a100-80gb-pcie`,
`a100-80gb-sxm`, `rtx-pro-6000`, `h100-sxm`, `h200-sxm`, and `b200`. See
[Cloud Training](../train/cloud-training.md) for the full list with pricing.

GET /api/models/{owner}/{project}/{model}/exports

POST /api/models/{owner}/{project}/{model}/exports

```bash
curl -X POST \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"format": "onnx", "args": {"imgsz": 640, "quantize": 16}}' \
  https://platform.ultralytics.com/api/models/acme-vision/inspection/v3/exports
```

```python
export = client.exports.create("acme-vision", "inspection", "v3", format="onnx", args={"imgsz": 640, "quantize": 16})
status = client.exports.retrieve("acme-vision", "inspection", "v3", export["id"])
print(status["export"]["status"])
```

GET /api/models/{owner}/{project}/{model}/exports/{exportId}

DELETE /api/models/{owner}/{project}/{model}/exports/{exportId}

{
    "success": true,
    "action": "cancelled"
}

graph LR
    A[Create]:::start --> B[Deploying]:::proc
    B --> C[Ready]:::out
    C -->|action stop| D[Stopped]:::extern
    C -->|action replace| B
    D -->|action start| C
    C -->|delete| E[Deleted]:::error
    D -->|delete| E
    C -->|predict| F[Inference Results]:::out

    classDef start fill:#4CAF50,color:#fff
    classDef proc fill:#2196F3,color:#fff
    classDef out fill:#9C27B0,color:#fff
    classDef error fill:#F44336,color:#fff
    classDef extern fill:#607D8B,color:#fff

GET /api/deployments/{owner}

POST /api/deployments/{owner}

{
    "project": "inspection",
    "model": "v3",
    "deployment": "edge-1",
    "name": "Edge 1",
    "region": "us-central1"
}

CPU, memory, and instance scaling are managed by the Platform from your plan limits, and the create request does not
accept a resource configuration. The current values are returned in the `resources` object on every deployment read.

Choose a region close to your users for lowest latency. The Platform UI shows latency estimates for all 42
available regions.

GET /api/deployments/{owner}/{deployment}

PATCH /api/deployments/{owner}/{deployment}

```json
{ "action": "start" }
```

```json
{ "action": "stop" }
```

```json
{
    "action": "replace",
    "project": "inspection",
    "model": "v4",
    "name": "Edge 1 (v4)"
}
```

DELETE /api/deployments/{owner}/{deployment}

GET /api/deployments/{owner}/{deployment}/health

POST /api/deployments/{owner}/{deployment}/predict

GET /api/deployments/{owner}/{deployment}/metrics

GET /api/deployments/{owner}/{deployment}/logs

GET /api/trash

POST /api/trash

{
    "id": "65f1c0a2b3d4e5f601234567",
    "type": "dataset"
}

DELETE /api/trash

{
    "id": "65f1c0a2b3d4e5f601234567",
    "type": "dataset"
}

{
    "all": true
}

Permanent deletion cannot be undone. The resource and all associated data are removed.

POST /api/upload/signed-url

{
    "assetType": "datasets",
    "assetId": "65f1c0a2b3d4e5f601234567",
    "filename": "warehouse.zip",
    "contentType": "application/zip",
    "totalBytes": 52428800
}

When `assetType` is `datasets`, `filename` must end in `.zip`, `.tar`, `.tar.gz`, `.tgz`, or `.ndjson`. Package
loose images into an archive before uploading.

{
    "sessionId": "session_abc123",
    "uploadUrl": "https://storage.googleapis.com/...&signature=...",
    "expiresAt": "2026-02-22T12:00:00Z"
}

POST /api/upload/complete

{
    "sessionId": "session_abc123",
    "checksum": "<optional sha-256 hex>"
}

GET /api/integrations/buckets

POST /api/integrations/buckets/discover

```json
{
    "provider": "gcs",
    "credentials": {
        "client_email": "[email protected]",
        "private_key": "-----BEGIN PRIVATE KEY-----\n...",
        "project_id": "my-project"
    }
}
```

```json
{
    "provider": "s3",
    "credentials": {
        "access_key_id": "AKIA...",
        "secret_access_key": "...",
        "region": "us-east-1"
    }
}
```

```json
{
    "provider": "azure",
    "credentials": {
        "connection_string": "DefaultEndpointsProtocol=https;AccountName=..."
    }
}
```

POST /api/integrations/buckets

GET /api/integrations/buckets/{id}/objects

DELETE /api/integrations/buckets/{id}

POST /api/integrations/roboflow/preview

{
    "apiKey": "ROBOFLOW_API_KEY"
}

POST /api/integrations/roboflow/import

{
    "apiKey": "ROBOFLOW_API_KEY",
    "items": [
        {
            "workspace": "my-workspace",
            "projectId": "warehouse-safety",
            "projectName": "Warehouse Safety",
            "projectType": "object-detection",
            "latestVersion": 4
        }
    ]
}

GET /api/account/summary

{
    "username": "acme-vision",
    "name": "Acme Vision",
    "accountType": "team",
    "plan": "pro",
    "creditsCents": 2500,
    "counts": { "projects": 4, "datasets": 7, "models": 21 },
    "teams": []
}

`teams` is populated for browser sessions. API-key responses return an empty list, because a key is already scoped
to a single workspace.

GET /api/api-keys

GET /api/storage

{
    "tier": "pro",
    "usage": {
        "storage": { "current": 1073741824, "limit": 107374182400, "percent": 1.0 },
        "datasets": { "current": 536870912, "limit": 107374182400, "percent": 0.5 }
    },
    "breakdown": {
        "byCategory": {
            "datasets": { "bytes": 536870912, "count": 2 },
            "models": { "bytes": 268435456, "count": 4 },
            "exports": { "bytes": 268435456, "count": 3 }
        },
        "topItems": [
            {
                "_id": "65f1c0a2b3d4e5f601234567",
                "name": "Warehouse",
                "slug": "warehouse",
                "sizeBytes": 536870912,
                "type": "dataset"
            }
        ]
    },
    "region": "us",
    "username": "acme-vision",
    "updatedAt": "2026-01-15T10:00:00Z"
}

GET /api/users

PATCH /api/users

{
    "username": "target-user",
    "followed": true
}

Billing amounts are integers in US cents, where `100 = $1.00`.

GET /api/billing/usage-summary

GET /api/billing/transactions

GET /api/explore/search

curl "https://platform.ultralytics.com/api/explore/search?type=datasets&task=detect&sort=stars&limit=20"

pip install "ultralytics-platform>=0.1.5" # Python 3.11+

from ultralytics_platform import Platform

with Platform() as client:  # reads ULTRALYTICS_API_KEY
    dataset = client.datasets.retrieve("acme-vision", "warehouse")
    images = client.datasets.images("acme-vision", "warehouse", limit=10)
    export = client.exports.create("acme-vision", "inspection", "v3", format="onnx")

pip install "ultralytics>=8.4.120"

yolo check

```bash
yolo login YOUR_API_KEY
```

```bash
export ULTRALYTICS_API_KEY=YOUR_API_KEY
```

```python
from ultralytics import settings

settings.update({"api_key": "YOUR_API_KEY"})
```

from ultralytics import YOLO

model = YOLO("yolo26n.pt")

# Train on your Platform dataset
model.train(
    data="ul://your-username/datasets/your-dataset",
    epochs=100,
    imgsz=640,
)

from ultralytics import YOLO

model = YOLO("yolo26n.pt")

# Results automatically sync to Platform
model.train(
    data="coco8.yaml",
    epochs=100,
    project="your-username/my-project",
    name="experiment-1",
)

# Your own model
model = YOLO("ul://username/project/model-name")

# Official model
model = YOLO("ul://ultralytics/yolo26/yolo26n")

results = model("image.jpg")

# Access results
for r in results:
    boxes = r.boxes  # Detection boxes
    masks = r.masks  # Segmentation masks
    keypoints = r.keypoints  # Pose keypoints
    probs = r.probs  # Classification probabilities

# Export to ONNX
model.export(format="onnx", imgsz=640, quantize=16)

# Export to TensorRT
model.export(format="engine", imgsz=640, quantize=16)

# Export to CoreML
model.export(format="coreml", imgsz=640)  # use imgsz=224 for classification

metrics = model.val(data="ul://username/datasets/my-dataset")

print(f"mAP50: {metrics.box.map50}")
print(f"mAP50-95: {metrics.box.map}")

curl -H "Authorization: Bearer YOUR_API_KEY" \
  "https://platform.ultralytics.com/api/datasets/acme-vision?limit=50"

curl "https://platform.ultralytics.com/api/explore/search?type=datasets&offset=20&limit=20&sort=stars"

curl -H "Authorization: Bearer YOUR_API_KEY" \
  "https://platform.ultralytics.com/api/datasets/acme-vision/warehouse/images?limit=1000&includeTotal=false&cursor=LAST_IMAGE_ID"

import time

import requests


def api_request_with_retry(url, headers, max_retries=3):
    for attempt in range(max_retries):
        response = requests.get(url, headers=headers)
        if response.status_code != 429:
            return response
        wait = int(response.headers.get("Retry-After", 2**attempt))
        time.sleep(wait)
    raise RuntimeError("Rate limit exceeded")