Monitoring#

Ultralytics Platform provides monitoring for deployed endpoints. Track endpoint requests, latency, errors, and logs. Paid dedicated endpoints also provide live prediction statistics and temporary examples that you can inspect and save to datasets.

Deployments Dashboard#

The Deploy page in the sidebar serves as the monitoring dashboard for all your deployments. It combines the world map, overview metrics, and deployment management in one view. See Dedicated Endpoints for creating and managing deployments.

graph TB
    subgraph Dashboard
        Map[World Map]:::proc --- Cards[Overview Cards]:::proc
        Cards --- List[Deployments List]:::decide
    end
    subgraph "Per Ready Deployment"
        Monitoring[Monitoring Tab: Paid Endpoints]:::out
        Metrics[Metrics Row]:::out
        Health[Health Check]:::out
        Logs[Logs Tab]:::out
        Code[Code Tab]:::out
        Predict[Predict Tab]:::out
    end
    List --> Monitoring
    List --> Metrics
    List --> Health
    List --> Logs
    List --> Code
    List --> Predict

    classDef proc fill:#2196F3,color:#fff
    classDef decide fill:#FF9800,color:#fff
    classDef out fill:#9C27B0,color:#fff

Overview Cards#

Four summary cards at the top of the page show:

P95 rather than median latency is reported because health checks return in a couple of milliseconds and would otherwise dominate the picture of real inference latency.

World Map#

The interactive world map shows:

• Region pins for all 42 available regions
• Green pins for regions with a ready deployment
• Animated blue pins for regions with active deployments in progress
• Pin size varies based on deployment status and latency

Click any region to open the New Deployment dialog. The map is hidden on small screens.

Deployments List#

Below the overview cards, the deployments list shows all endpoints across your projects. Use the view mode toggle to switch between:

Per-Deployment Metrics#

Each deployment card (in cards view) shows real-time metrics. The metrics row, health check, and the Logs, Code, and Predict tabs described below appear only while the deployment is Ready:

Metrics Row#

Metrics refresh automatically. Endpoints that have not served a request show "No traffic yet", and metrics are collected only for deployments in the Ready state. On the deployments dashboard, metrics are fetched for the 20 most recent deployments.

Health Check#

Running deployments show a health check indicator:

Health checks auto-retry while unhealthy and stop once the endpoint responds. Click the refresh icon to manually trigger a health check, which doubles as a way to warm a scaled-to-zero endpoint before sending traffic.

Monitoring Tab#

Open Deploy, switch to Cards view, and select Monitoring on a Ready, paid dedicated endpoint. Send an image through its Predict tab or endpoint API to populate Temporary Examples and Prediction Statistics. Before the first processed image, the tab shows No images processed.

Temporary Examples#

The gallery contains a rolling sample of processed images with prediction overlays. Open an image to inspect its predictions in the full-screen viewer and use the visibility controls to adjust the overlays. The gallery initially shows up to 12 examples; Show all expands it.

• Sampling: Up to two examples initially, then up to one additional image per minute. Capture is best effort; inference does not wait for example encoding.
• Capacity: At most 100 images within a shared 100 MiB memory budget for compressed images, prediction metadata, and associated assets. The interface labels this budget as 100 MB.
• Replacement: Older examples are replaced when either limit is reached. An example may become unavailable while you are viewing it.
• Storage: Temporary examples remain in endpoint memory. Saving them to a dataset uses normal workspace storage and processing limits.

Save Examples to a Dataset#

Workspace members with content editing permission can save examples to a dataset in the endpoint's workspace:

1. Select individual examples using their checkboxes, or click Select all.
2. Click Save to dataset.
3. Choose an existing dataset with the same task as the deployed model. Connected-source datasets are excluded; create a compatible dataset first if none is available.
4. Click the Save button, which shows the selected image count, then open the dataset to follow processing.

Selected images and predictions are copied through the standard dataset upload and ingestion workflow. Normal quota, class mapping, and duplicate handling apply. Saving leaves the temporary examples in the gallery; successfully ingested dataset images survive endpoint restarts and deletion. Review predicted labels before using them for training.

To remove temporary examples, use an image's hover trash control or select examples and click the bulk trash button, then confirm Delete. Deleting examples leaves aggregate prediction statistics and images already saved to datasets unchanged.

Prediction Statistics#

Statistics aggregate processed images independently of gallery sampling. Deleting or replacing an example does not subtract its contribution. The summary shows images, predictions, and images without predictions for the selected period; depth models show image counts.

The date picker defaults to the last 30 days and accepts ranges up to 365 days. Selected dates use UTC boundaries; chart timestamps display in local time. Recent ranges of up to three days use hourly history when the full range falls within the last 72 hours; other ranges use daily history. The date range filters statistics, while the gallery continues to show the current temporary examples.

History is bounded to 72 hourly buckets and 365 daily buckets, and is available only since the current instance started. A selected period with no processed images shows No images processed in this period.

Available charts depend on the task and collected predictions:

Monitoring refreshes about every 2 seconds while its panel is open and visible. Polling pauses when the panel is offscreen or the browser tab is hidden. Successful inference through the deployment's Predict tab also triggers a statistics refresh.

Logs#

Each deployment card includes a Logs tab for viewing recent log entries:

Log Entries#

Each log entry shows:

The UI shows the 20 most recent entries and hides empty ones. The API defaults to 50 entries per request (max 200) and returns a nextPageToken for paging further back.

Code Examples#

Each deployment card includes a Code tab showing ready-to-use API code with the endpoint URL filled in. For workspace owners, the deployment's bound API key is inserted, ready to copy and run. Non-owners see a YOUR_API_KEY placeholder:

import requests

# Deployment endpoint
url = "https://YOUR_DEPLOYMENT_URL.run.app/predict"

# Headers with your deployment API key
headers = {"Authorization": "Bearer YOUR_API_KEY"}

# Inference parameters
data = {"conf": 0.25, "iou": 0.7, "imgsz": 640}

# Send image for inference
with open("image.jpg", "rb") as f:
    response = requests.post(url, headers=headers, data=data, files={"file": f})

print(response.json())

Deployment Predict#

The Predict tab on each deployment card provides an inline predict panel — the same interface as the model's Predict tab, but running inference through the deployment endpoint instead of the shared service. This is useful for testing a deployed endpoint directly from the browser. See Inference for parameter details and response formats.

API Endpoints#

Every deployment is addressed by its owner and deployment name, and each route requires an API key. See the API reference for authentication details.

Deployment Metrics#

GET /api/deployments/{owner}/{deployment}/metrics?range=24h

Python SDK: client.deployments.metrics(owner, deployment, range="24h")

Returns the full metrics payload for a deployment: a summary block with total requests, error count and rate, and average, P50, P95, and P99 latency, plus timeSeries arrays for requests, errors, P50 and P95 latency, CPU and memory utilization, and instance count.

With sparkline=true, the response is the compact form the deployment cards use — 24 hourly request counts plus total requests, error rate, and average latency. This is the call that refreshes every 60 seconds.

Deployment Logs#

GET /api/deployments/{owner}/{deployment}/logs?limit=50&severity=ERROR,WARNING

Python SDK: client.deployments.logs(owner, deployment, limit=50, severity="ERROR,WARNING")

Returns recent log entries with optional severity filter and pagination.

Deployment Health#

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

Python SDK: client.deployments.health(owner, deployment)

Pings the deployment and returns its health status with the measured round-trip latency:

{
    "healthy": true,
    "status": 200,
    "latencyMs": 142
}

An unhealthy response omits status when the endpoint could not be reached at all, and adds an error message.

Performance Optimization#

Use monitoring data to optimize your deployments:

FAQ#