Référence de l'API REST

La plateforme Ultralytics fournit une API REST complète pour l'accès programmatique aux jeux de données, aux modèles, à l'entraînement et aux déploiements.

# List your datasets
curl -H "Authorization: Bearer YOUR_API_KEY" \
  https://platform.ultralytics.com/api/datasets

Présentation de l'API

L'API est organisée autour des ressources principales de la plateforme :

graph LR
    A[API Key] --> B[Datasets]
    A --> C[Projects]
    A --> D[Models]
    A --> E[Deployments]
    B -->|train on| D
    C -->|contains| D
    D -->|deploy to| E
    D -->|export| F[Exports]
    B -->|auto-annotate| B

Authentification

La plupart des requêtes API nécessitent une authentification via une clé API. Les points de terminaison publics (répertoriant les ensembles de données, les projets et les modèles publics) prennent en charge l'accès en lecture anonyme sans clé.

Obtenir la clé API

1. Aller à Settings > Profile (Section Clés API)
2. Cliquez Create Key
3. Copiez la clé générée

Consultez les Clés API pour des instructions détaillées.

En-tête d'autorisation

Incluez votre clé API dans toutes les requêtes :

Authorization: Bearer ul_your_api_key_here

Exemple

curl -H "Authorization: Bearer ul_abc123..." \
  https://platform.ultralytics.com/api/datasets

import requests

headers = {"Authorization": "Bearer ul_abc123..."}
response = requests.get(
    "https://platform.ultralytics.com/api/datasets",
    headers=headers,
)
data = response.json()

const response = await fetch("https://platform.ultralytics.com/api/datasets", {
  headers: { Authorization: "Bearer ul_abc123..." },
});
const data = await response.json();

URL de base

Tous les points d'accès API utilisent :

https://platform.ultralytics.com/api

Limites de débit

L'API utilise un système de limitation de débit à deux niveaux pour se protéger contre les abus tout en laissant libre cours aux utilisations légitimes :

• Par clé API — Limites appliquées par clé API sur les requêtes authentifiées
• Par IP — 100 requêtes/min par adresse IP sur tous les /api/* chemins (s'applique aux requêtes authentifiées et non authentifiées)

Lorsqu'elle est limitée, l'API renvoie 429 avec les métadonnées de nouvelle tentative :

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

Limites par clé API

Les limites de débit sont appliquées automatiquement en fonction du point de terminaison appelé. Les opérations coûteuses ont des limites plus strictes afin d'éviter les abus, tandis que les opérations CRUD standard bénéficient d'une limite par défaut généreuse :

Chaque catégorie dispose d'un compteur indépendant par clé API. Par exemple, effectuer 20 requêtes de prédiction n'affecte pas votre quota par défaut de 100 requêtes/minute.

Terminaux dédiés (illimités)

Terminaux dédiés sont non soumis aux limites de débit des clés APILorsque vous déployez un modèle sur un point de terminaison dédié, les requêtes adressées à l'URL de ce point de terminaison (par exemple, https://predict-abc123.run.app/predict) accédez directement à votre service dédié sans limitation de débit depuis la plateforme. Vous payez pour la puissance de calcul, vous bénéficiez donc d'un débit illimité jusqu'à la configuration de mise à l'échelle de votre point de terminaison.

Format de réponse

Réponses positives

Les réponses renvoient un JSON avec des champs spécifiques à la ressource :

{
    "datasets": [...],
    "total": 100
}

Réponses d'erreur

{
    "error": "Invalid dataset ID"
}

API des jeux de données

Gérer des collections d'images étiquetées pour l'entraînement YOLO .

Lister les ensembles de données

GET /api/datasets

Paramètres de requête :

curl -H "Authorization: Bearer $API_KEY" \
  "https://platform.ultralytics.com/api/datasets?limit=10"

import requests

resp = requests.get(
    "https://platform.ultralytics.com/api/datasets",
    headers={"Authorization": f"Bearer {API_KEY}"},
    params={"limit": 10},
)
for ds in resp.json()["datasets"]:
    print(f"{ds['name']}: {ds['imageCount']} images")

Réponse :

{
    "datasets": [
        {
            "_id": "dataset_abc123",
            "name": "my-dataset",
            "slug": "my-dataset",
            "task": "detect",
            "imageCount": 1000,
            "classCount": 10,
            "classNames": ["person", "car"],
            "visibility": "private",
            "username": "johndoe",
            "starCount": 3,
            "isStarred": false,
            "sampleImages": [
                {
                    "url": "https://storage.example.com/...",
                    "width": 1920,
                    "height": 1080,
                    "labels": [{ "classId": 0, "bbox": [0.5, 0.4, 0.3, 0.6] }]
                }
            ],
            "createdAt": "2024-01-15T10:00:00Z",
            "updatedAt": "2024-01-16T08:30:00Z"
        }
    ],
    "total": 1,
    "region": "us"
}

Obtenir un jeu de données

GET /api/datasets/{datasetId}

Renvoie tous les détails de l'ensemble de données, y compris les métadonnées, les noms de classe et les nombres de divisions.

Créer un jeu de données

POST /api/datasets

Corps :

{
    "slug": "my-dataset",
    "name": "My Dataset",
    "task": "detect",
    "description": "A custom detection dataset",
    "visibility": "private",
    "classNames": ["person", "car"]
}

Mettre à jour l'ensemble de données

PATCH /api/datasets/{datasetId}

Corps (mise à jour partielle) :

{
    "name": "Updated Name",
    "description": "New description",
    "visibility": "public"
}

Supprimer l'ensemble de données

DELETE /api/datasets/{datasetId}

Supprime temporairement l'ensemble de données (déplacé vers la corbeille, récupérable pendant 30 jours).

Cloner le jeu de données

POST /api/datasets/{datasetId}/clone

Crée une copie du jeu de données avec toutes les images et toutes les étiquettes. Seuls les jeux de données publics peuvent être clonés.

Corps (tous les champs sont facultatifs) :

{
    "name": "cloned-dataset",
    "description": "My cloned dataset",
    "visibility": "private",
    "owner": "team-username"
}

Exporter le jeu de données

GET /api/datasets/{datasetId}/export

Renvoie une réponse JSON avec une URL de téléchargement signée pour le fichier d'exportation de l'ensemble de données.

Réponse :

{
    "downloadUrl": "https://storage.example.com/export.ndjson?signed=...",
    "cached": true
}

Obtenir les statistiques de classe

GET /api/datasets/{datasetId}/class-stats

Renvoie la distribution des classes, la carte thermique des emplacements et les statistiques dimensionnelles. Les résultats sont mis en cache pendant 5 minutes maximum.

Réponse :

{
    "classes": [{ "classId": 0, "count": 1500, "imageCount": 450 }],
    "imageStats": {
        "widthHistogram": [{ "bin": 640, "count": 120 }],
        "heightHistogram": [{ "bin": 480, "count": 95 }],
        "pointsHistogram": [{ "bin": 4, "count": 200 }]
    },
    "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", "car", "dog"],
    "cached": true,
    "sampled": false,
    "sampleSize": 1000
}

Obtenir des modèles formés sur un ensemble de données

GET /api/datasets/{datasetId}/models

Renvoie les modèles qui ont été entraînés à l'aide de cet ensemble de données.

Réponse :

{
    "models": [
        {
            "_id": "model_abc123",
            "name": "experiment-1",
            "slug": "experiment-1",
            "status": "completed",
            "task": "detect",
            "epochs": 100,
            "bestEpoch": 87,
            "projectId": "project_xyz",
            "projectSlug": "my-project",
            "projectIconColor": "#3b82f6",
            "projectIconLetter": "M",
            "username": "johndoe",
            "startedAt": "2024-01-14T22:00:00Z",
            "completedAt": "2024-01-15T10:00:00Z",
            "createdAt": "2024-01-14T21:55:00Z",
            "metrics": {
                "mAP50": 0.85,
                "mAP50-95": 0.72,
                "precision": 0.88,
                "recall": 0.81
            }
        }
    ],
    "count": 1
}

Annotation automatique des ensembles de données

POST /api/datasets/{datasetId}/predict

Exécutez YOLO sur les images de l'ensemble de données pour générer automatiquement des annotations. Utilise un modèle sélectionné pour prédire les étiquettes des images non annotées.

Corps :

Ingestion de données

POST /api/datasets/ingest

Créez une tâche d'ingestion de données pour traiter les fichiers ZIP téléchargés contenant des images et des étiquettes.

graph LR
    A[Upload ZIP] --> B[POST /api/datasets/ingest]
    B --> C[Process ZIP]
    C --> D[Extract images]
    C --> E[Parse labels]
    C --> F[Generate thumbnails]
    D & E & F --> G[Dataset ready]

Ensemble de données Images

Liste des images

GET /api/datasets/{datasetId}/images

Paramètres de requête :

Obtenir les URL des images signées

POST /api/datasets/{datasetId}/images/urls

Obtenir des URL signées pour un lot de hachages d'images (à afficher dans le navigateur).

Supprimer l'image

DELETE /api/datasets/{datasetId}/images/{hash}

Obtenir des étiquettes d'image

GET /api/datasets/{datasetId}/images/{hash}/labels

Renvoie les annotations et les noms de classe pour une image spécifique.

Mettre à jour les étiquettes d'image

PUT /api/datasets/{datasetId}/images/{hash}/labels

Corps :

{
    "labels": [{ "classId": 0, "bbox": [0.5, 0.5, 0.2, 0.3] }]
}

Opérations groupées sur les images

Déplacer des images entre les divisions (train/val/test) au sein d'un ensemble de données :

PATCH /api/datasets/{datasetId}/images/bulk

Suppression groupée d'images :

DELETE /api/datasets/{datasetId}/images/bulk

API des projets

Gérer les espaces de travail de formation qui regroupent les modèles.

Lister les projets

GET /api/projects

Paramètres de requête :

Obtenir un projet

GET /api/projects/{projectId}

Créer un projet

POST /api/projects

curl -X POST \
  -H "Authorization: Bearer $API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"name": "my-project", "slug": "my-project", "description": "Detection experiments"}' \
  https://platform.ultralytics.com/api/projects

resp = requests.post(
    "https://platform.ultralytics.com/api/projects",
    headers={"Authorization": f"Bearer {API_KEY}"},
    json={"name": "my-project", "slug": "my-project", "description": "Detection experiments"},
)
project_id = resp.json()["projectId"]

Mettre à jour le projet

PATCH /api/projects/{projectId}

Supprimer le projet

DELETE /api/projects/{projectId}

Supprime temporairement le projet (déplacé vers la corbeille).

Projet Clone

POST /api/projects/{projectId}/clone

Icône du projet

Télécharger une icône de projet (formulaire en plusieurs parties avec fichier image) :

POST /api/projects/{projectId}/icon

Supprimer l'icône du projet :

DELETE /api/projects/{projectId}/icon

API des modèles

Gérer les points de contrôle des modèles entraînés au sein des projets.

Lister les modèles

GET /api/models

Paramètres de requête :

Liste des modèles terminés

GET /api/models/completed

Renvoie les modèles dont la formation est terminée (à utiliser dans les sélecteurs de modèles et le déploiement).

Obtenir le modèle

GET /api/models/{modelId}

Créer un modèle

POST /api/models

Corps JSON :

Mettre à jour le modèle

PATCH /api/models/{modelId}

Supprimer le modèle

DELETE /api/models/{modelId}

Télécharger les fichiers modèles

GET /api/models/{modelId}/files

Renvoie les URL de téléchargement signées pour les fichiers de modèle.

Modèle clone

POST /api/models/{modelId}/clone

Clonez un modèle public dans l'un de vos projets.

Corps :

{
    "targetProjectSlug": "my-project",
    "modelName": "cloned-model",
    "description": "Cloned from public model",
    "owner": "team-username"
}

Suivre le téléchargement

POST /api/models/{modelId}/track-download

Suivre les statistiques de téléchargement des modèles.

Exécuter l'inférence

POST /api/models/{modelId}/predict

Formulaire multipartie :

curl -X POST \
  -H "Authorization: Bearer $API_KEY" \
  -F "file=@image.jpg" \
  -F "conf=0.5" \
  https://platform.ultralytics.com/api/models/MODEL_ID/predict

with open("image.jpg", "rb") as f:
    resp = requests.post(
        f"https://platform.ultralytics.com/api/models/{model_id}/predict",
        headers={"Authorization": f"Bearer {API_KEY}"},
        files={"file": f},
        data={"conf": 0.5},
    )
results = resp.json()["images"][0]["results"]

Réponse :

{
    "images": [
        {
            "shape": [1080, 1920],
            "results": [
                {
                    "class": 0,
                    "name": "person",
                    "confidence": 0.92,
                    "box": { "x1": 100, "y1": 50, "x2": 300, "y2": 400 }
                }
            ]
        }
    ],
    "metadata": {
        "imageCount": 1
    }
}

Obtenir un jeton Predict

POST /api/models/{modelId}/predict/token

Obtenez un jeton à durée limitée pour les demandes de prédiction directe. Le jeton contourne le proxy API pour une inférence à faible latence à partir des applications côté client.

Modèle d'échauffement

POST /api/models/{modelId}/predict/warmup

Préchargez un modèle pour accélérer la première inférence. Appelez cette fonction avant d'exécuter les prédictions afin d'éviter tout retard lors de la requête initiale.

API d'entraînement

Démarrer, surveiller et annuler les tâches de formation dans le cloud.

graph LR
    A[POST /training/start] --> B[Job Created]
    B --> C{Training}
    C -->|progress| D[GET /models/id/training]
    C -->|cancel| E[DELETE /models/id/training]
    C -->|complete| F[Model Ready]
    F --> G[Deploy or Export]

Démarrer l'entraînement

POST /api/training/start

curl -X POST \
  -H "Authorization: Bearer $API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "modelId": "MODEL_ID",
    "projectId": "PROJECT_ID",
    "gpuType": "rtx-4090",
    "trainArgs": {
      "model": "yolo11n.pt",
      "data": "ul://username/datasets/my-dataset",
      "epochs": 100,
      "imgsz": 640,
      "batch": 16
    }
  }' \
  https://platform.ultralytics.com/api/training/start

resp = requests.post(
    "https://platform.ultralytics.com/api/training/start",
    headers={"Authorization": f"Bearer {API_KEY}"},
    json={
        "modelId": "MODEL_ID",
        "projectId": "PROJECT_ID",
        "gpuType": "rtx-4090",
        "trainArgs": {
            "model": "yolo11n.pt",
            "data": "ul://username/datasets/my-dataset",
            "epochs": 100,
            "imgsz": 640,
            "batch": 16,
        },
    },
)

Obtenir le statut d'entraînement

GET /api/models/{modelId}/training

Renvoie l'état actuel de la tâche d'entraînement, les métriques et la progression d'un modèle.

Annuler l'entraînement

DELETE /api/models/{modelId}/training

Met fin à l'instance de calcul en cours d'exécution et marque le travail comme annulé.

API des déploiements

Créer et gérer des points de terminaison d'inférence dédiés.

graph LR
    A[Create] --> B[Deploying]
    B --> C[Ready]
    C -->|stop| D[Stopped]
    D -->|start| C
    C -->|delete| E[Deleted]
    D -->|delete| E
    C -->|predict| F[Inference Results]

Lister les déploiements

GET /api/deployments

Paramètres de requête :

Créer un déploiement

POST /api/deployments

Corps :

{
    "modelId": "model_abc123",
    "name": "my-deployment",
    "region": "us-central1",
    "resources": {
        "cpu": 1,
        "memoryGi": 2,
        "minInstances": 0,
        "maxInstances": 1
    }
}

Crée un point de terminaison d'inférence dédié dans la région spécifiée. Le point de terminaison est accessible globalement via une URL unique.

Obtenir le déploiement

GET /api/deployments/{deploymentId}

Supprimer le déploiement

DELETE /api/deployments/{deploymentId}

Démarrer le déploiement

POST /api/deployments/{deploymentId}/start

Reprendre un déploiement interrompu.

Arrêter le déploiement

POST /api/deployments/{deploymentId}/stop

Suspendre un déploiement en cours (arrête la facturation).

Vérification de l'état

GET /api/deployments/{deploymentId}/health

Renvoie l'état de santé du point de terminaison de déploiement.

Exécuter l'inférence lors du déploiement

POST /api/deployments/{deploymentId}/predict

Envoyez une image directement à un point de terminaison de déploiement pour l'inférence. Fonctionnellement équivalent à la prédiction du modèle, mais acheminé via le point de terminaison dédié pour une latence réduite.

Formulaire multipartie :

Obtenir les métriques

GET /api/deployments/{deploymentId}/metrics

Renvoie les métriques relatives au nombre de demandes, à la latence et au taux d'erreur avec des données sparkline.

Paramètres de requête :

Obtenir les journaux

GET /api/deployments/{deploymentId}/logs

Paramètres de requête :

API de surveillance

Mesures agrégées

GET /api/monitoring

Renvoie des mesures agrégées pour tous les déploiements utilisateur : nombre total de requêtes, déploiements actifs, taux d'erreur et latence moyenne.

API d'exportation

Convertissez les modèles en formats optimisés pour un déploiement en périphérie.

Lister les exportations

GET /api/exports

Paramètres de requête :

Créer une exportation

POST /api/exports

Corps :

curl -X POST \
  -H "Authorization: Bearer $API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"modelId": "MODEL_ID", "format": "onnx"}' \
  https://platform.ultralytics.com/api/exports

resp = requests.post(
    "https://platform.ultralytics.com/api/exports",
    headers={"Authorization": f"Bearer {API_KEY}"},
    json={"modelId": "MODEL_ID", "format": "onnx"},
)
export_id = resp.json()["exportId"]

Formats pris en charge :

Obtenir le statut d'exportation

GET /api/exports/{exportId}

Annuler l'exportation

DELETE /api/exports/{exportId}

Suivre l'exportation Télécharger

POST /api/exports/{exportId}/track-download

API d'activité

track et gérer les événements d'activité de votre compte.

Lister l'activité

GET /api/activity

Paramètres de requête :

Marquer les événements comme vus

POST /api/activity/mark-seen

Corps :

{
    "all": true
}

Ou transmettre des identifiants spécifiques :

{
    "eventIds": ["EVENT_ID_1", "EVENT_ID_2"]
}

Archiver les événements

POST /api/activity/archive

Corps :

{
    "all": true,
    "archive": true
}

Ou transmettre des identifiants spécifiques :

{
    "eventIds": ["EVENT_ID_1", "EVENT_ID_2"],
    "archive": false
}

API Corbeille

Gérer les ressources supprimées logiquement (rétention de 30 jours).

Lister la corbeille

GET /api/trash

Paramètres de requête :

Restaurer l'élément

POST /api/trash

Corps :

{
    "id": "item_abc123",
    "type": "dataset"
}

Supprimer définitivement l'élément

DELETE /api/trash

Corps :

{
    "id": "item_abc123",
    "type": "dataset"
}

Vider la corbeille

DELETE /api/trash/empty

Supprime définitivement tous les éléments de la corbeille.

API Facturation

Gérez les crédits, les abonnements et les modes de paiement.

Obtenir le solde

GET /api/billing/balance

Paramètres de requête :

Réponse :

{
    "creditsCents": 2500,
    "plan": "free",
    "cashBalance": 25,
    "creditBalance": 0,
    "reservedAmount": 0,
    "totalBalance": 25
}

Obtenir le résumé d'utilisation

GET /api/billing/usage-summary

Retourne les détails du plan, les limites et les métriques d'utilisation.

Obtenir les transactions

GET /api/billing/transactions

Renvoie l'historique des transactions (les plus récentes en premier).

Paramètres de requête :

Créer une session de paiement

POST /api/billing/checkout-session

Corps :

{
    "amount": 25,
    "owner": "team-username"
}

Crée une session de paiement pour un achat à crédit.

Créer un paiement d'abonnement

POST /api/billing/subscription-checkout

Crée une session de paiement pour la mise à niveau vers l'abonnement Pro.

Corps :

{
    "planId": "pro",
    "billingCycle": "monthly",
    "owner": "team-username"
}

Créer une session de portail

POST /api/billing/portal-session

Renvoie l'URL vers le portail de facturation pour la gestion des abonnements.

Recharge automatique

Ajouter automatiquement des crédits lorsque le solde passe en dessous d'un seuil.

Obtenir la configuration de la recharge automatique

GET /api/billing/auto-topup

Paramètres de requête :

Mettre à jour la configuration de la recharge automatique

PATCH /api/billing/auto-topup

Corps :

{
    "enabled": true,
    "thresholdCents": 500,
    "amountCents": 2500
}

Méthodes de paiement

Liste des modes de paiement

GET /api/billing/payment-methods

Créer une intention de configuration

POST /api/billing/payment-methods/setup

Renvoie un secret client pour ajouter un nouveau mode de paiement.

Définir le mode de paiement par défaut

POST /api/billing/payment-methods/default

Corps :

{
    "paymentMethodId": "pm_123"
}

Mettre à jour les informations de facturation

PATCH /api/billing/payment-methods

Corps :

{
    "name": "Jane Doe",
    "address": {
        "line1": "123 Main St",
        "city": "San Francisco",
        "state": "CA",
        "postal_code": "94105",
        "country": "US"
    }
}

Supprimer le mode de paiement

DELETE /api/billing/payment-methods/{id}

API Stockage

Obtenir les informations de stockage

GET /api/storage

Réponse :

{
    "tier": "free",
    "usage": {
        "storage": {
            "current": 1073741824,
            "limit": 107374182400,
            "percent": 1.0
        }
    },
    "region": "us",
    "username": "johndoe",
    "updatedAt": "2024-01-15T10:00:00Z",
    "breakdown": {
        "byCategory": {
            "datasets": { "bytes": 536870912, "count": 2 },
            "models": { "bytes": 268435456, "count": 4 },
            "exports": { "bytes": 268435456, "count": 3 }
        },
        "topItems": [
            {
                "_id": "dataset_abc123",
                "name": "my-dataset",
                "slug": "my-dataset",
                "sizeBytes": 536870912,
                "type": "dataset"
            },
            {
                "_id": "model_def456",
                "name": "experiment-1",
                "slug": "experiment-1",
                "sizeBytes": 134217728,
                "type": "model",
                "parentName": "My Project",
                "parentSlug": "my-project"
            }
        ]
    }
}

Recalculer le stockage

POST /api/storage

Déclenche un nouveau calcul de l'utilisation du stockage.

API de téléchargement

Les téléchargements directs de fichiers utilisent un flux d'URL signé en deux étapes.

Obtenir l'URL de téléchargement signée

POST /api/upload/signed-url

Demandez une URL signée pour télécharger un fichier directement vers le stockage cloud. L'URL signée contourne le serveur API pour les transferts de fichiers volumineux.

Corps :

{
    "assetType": "images",
    "assetId": "abc123",
    "filename": "my-image.jpg",
    "contentType": "image/jpeg",
    "totalBytes": 5242880
}

Réponse :

{
    "sessionId": "session_abc123",
    "uploadUrl": "https://storage.example.com/...",
    "objectPath": "images/abc123/my-image.jpg",
    "downloadUrl": "https://cdn.example.com/...",
    "expiresAt": "2026-02-22T12:00:00Z"
}

Téléchargement complet

POST /api/upload/complete

Informez la plateforme que le téléchargement d'un fichier est terminé afin qu'elle puisse commencer le traitement.

Corps :

{
    "datasetId": "abc123",
    "objectPath": "datasets/abc123/images/my-image.jpg",
    "filename": "my-image.jpg",
    "contentType": "image/jpeg",
    "size": 5242880
}

API Clés API

Lister les clés API

GET /api/api-keys

Créer une clé API

POST /api/api-keys

Corps :

{
    "name": "training-server"
}

Supprimer une clé API

DELETE /api/api-keys

Paramètres de requête :

Exemple :

curl -X DELETE \
  -H "Authorization: Bearer $API_KEY" \
  "https://platform.ultralytics.com/api/api-keys?keyId=KEY_ID"

API Équipes et membres

Gérez la collaboration dans l'espace de travail avec les équipes, les membres et les invitations.

Liste des équipes

GET /api/teams

Créer une équipe

POST /api/teams/create

Corps :

{
    "username": "my-team",
    "fullName": "My Team"
}

Liste des membres

GET /api/members

Renvoie les membres de l'espace de travail actuel.

Inviter un membre

POST /api/members

Corps :

{
    "email": "user@example.com",
    "role": "editor"
}

Mettre à jour le rôle des membres

PATCH /api/members/{userId}

Supprimer le membre

DELETE /api/members/{userId}

Transfert de propriété

POST /api/members/transfer-ownership

Invitations

Accepter l'invitation

POST /api/invites/accept

Obtenir les informations relatives à l'invitation

GET /api/invites/info

Paramètres de requête :

Annuler l'invitation

DELETE /api/invites/{inviteId}

Renvoyer l'invitation

POST /api/invites/{inviteId}/resend

Explorer l'API

Rechercher du contenu public

GET /api/explore/search

Paramètres de requête :

Données de la barre latérale

GET /api/explore/sidebar

Renvoie du contenu sélectionné pour la barre latérale Explorer.

API utilisateur et paramètres

Obtenir l'utilisateur par nom d'utilisateur

GET /api/users

Paramètres de requête :

Suivre ou ne plus suivre un utilisateur

PATCH /api/users

Corps :

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

Vérifier la disponibilité du nom d'utilisateur

GET /api/username/check

Paramètres de requête :

Paramètres

GET /api/settings
POST /api/settings

Obtenir ou mettre à jour les paramètres du profil utilisateur (nom d'affichage, biographie, liens vers les réseaux sociaux, etc.).

Icône de profil

POST /api/settings/icon
DELETE /api/settings/icon

Télécharger ou supprimer l'avatar du profil.

Intégration

POST /api/onboarding

Processus d'intégration complet (définition de la région de données, nom d'utilisateur).

API RGPD

Points d'accès de conformité RGPD pour l'exportation et la suppression de données.

Obtenir le statut d'emploi RGPD

GET /api/gdpr

Paramètres de requête :

Renvoie le statut de la tâche. Pour les tâches d'exportation terminées, la réponse inclut un downloadUrl.

Lancer l'exportation ou supprimer le flux

POST /api/gdpr

Corps :

{
    "action": "export"
}

{
    "action": "delete",
    "confirmationWord": "DELETE"
}

Facultatif pour les espaces de travail d'équipe :

{
    "action": "delete",
    "confirmationWord": "DELETE",
    "teamUsername": "my-team"
}

Codes d'erreur

Python

Pour faciliter l'intégration, utilisez lePython Ultralytics qui gère automatiquement l'authentification, les téléchargements et la diffusion en temps réel des métriques.

Installation et configuration

pip install ultralytics

Vérifier l'installation :

yolo check

Authentification

yolo settings api_key=YOUR_API_KEY

export ULTRALYTICS_API_KEY=YOUR_API_KEY

from ultralytics import settings

settings.api_key = "YOUR_API_KEY"

Utilisation des jeux de données de la plateforme

Ensembles de données de référence avec ul:// URI :

from ultralytics import YOLO

model = YOLO("yolo11n.pt")

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

Format URI :

Poussée vers la plateforme

Envoyer les résultats à un projet Platform :

from ultralytics import YOLO

model = YOLO("yolo11n.pt")

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

Ce qui se synchronise :

• Indicateurs de formation (en temps réel)
• Poids des modèles finaux
• Graphiques de validation
• Sortie de la console
• Mesures du système

Exemples d'API

Charger un modèle depuis Platform :

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

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

Exécuter l'inférence :

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

Modèle d'exportation :

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

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

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

Validation :

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

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

Webhooks

Les webhooks informent votre serveur des événements de la plateforme via des rappels HTTP POST :

FAQ

Comment paginer de grands ensembles de résultats ?

La plupart des terminaux utilisent un limit paramètre permettant de contrôler le nombre de résultats renvoyés par requête :

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

Les points de terminaison Activity et Trash prennent également en charge un page paramètre pour la pagination basée sur les pages :

curl -H "Authorization: Bearer $API_KEY" \
  "https://platform.ultralytics.com/api/activity?page=2&limit=20"

Le point de terminaison Explore Search utilise offset au lieu de page, avec une taille de page fixe de 20 :

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

Puis-je utiliser l'API sans SDK ?

Oui, toutes les fonctionnalités sont disponibles via REST. Le Python est un wrapper pratique qui ajoute des fonctionnalités telles que le streaming de métriques en temps réel et le téléchargement automatique de modèles.

Existe-t-il des bibliothèques clientes API ?

Actuellement, utilisez le package python Ultralytics ou effectuez des requêtes HTTP directes. Des bibliothèques clientes officielles pour d'autres langages sont prévues.

Comment gérer les limites de débit ?

Utilisez la Retry-After En-tête de la réponse 429 pour attendre le temps nécessaire :

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 Exception("Rate limit exceeded")

Comment trouver l'ID de mon modèle ou de mon ensemble de données ?

Les identifiants de ressources sont renvoyés lorsque vous créez des ressources via l'API. Vous pouvez également les trouver dans l'URL de la plateforme :

https://platform.ultralytics.com/username/project/model-name
                                  ^^^^^^^^ ^^^^^^^ ^^^^^^^^^^
                                  username project   model

Utilisez les points de terminaison de la liste pour effectuer une recherche par nom ou filtrer par projet.

📅 Créé il y a 1 mois ✏️ Mis à jour il y a 4 jours

Commentaires