Roboflow

Ultralytics: YOLOv8

YOLOv8 Overview

YOLOv8 is an object detection and multi-task vision model developed by Ultralytics, released in January 2023 under the AGPL-3.0 license. It succeeds YOLOv5 and introduces an anchor-free detection head, a new C2f module for improved gradient flow, and a decoupled head that separates classification and regression tasks. These changes improve both accuracy and training efficiency compared to earlier Ultralytics models.

YOLOv8 supports object detection, instance segmentation, image classification, pose estimation, and oriented bounding box detection within a unified codebase. It is available in five sizes from Nano to Extra Large and exports to ONNX, TensorRT, CoreML, and other formats. YOLOv8 is one of the most widely adopted detection models in production and is directly supported by Roboflow Inference for custom model training and deployment.

YOLOv8 Interactive Demo

YOLOv8 Details & Performance

Details

Resources

GitHubColabTutorialVideo

Vision Tasks

Object Detection

Features

Real-Time Vision

Usage

Past 30 Days

Performance

Avg. Latency

Arena Rankings

Not yet ranked in arena

Alternatives to YOLOv8

Other models worth comparing for similar use cases.

YOLO26
YOLO26 is a real-time object detection model developed by Ultralytics, released in October 2025. It introduces a native end-to-end, NMS-free architecture that eliminates the Non-Maximum Suppression post-processing step, reducing CPU latency by up to 43% for the Nano variant compared to NMS-dependent versions. The model incorporates the MuSGD optimizer and ProgLoss with STAL for improved training stability and small-object detection, and removes Distribution Focal Loss to ensure maximum compatibility with ONNX and TensorRT export targets.YOLO26 supports object detection, instance segmentation, pose estimation, and oriented bounding box detection within a unified framework, with model sizes available from Nano to Extra Large. Its NMS-free design makes it particularly well suited for deployment scenarios where post-processing overhead is a bottleneck, such as embedded systems and real-time edge inference pipelines.
YOLO11
YOLO11 is an object detection and multi-task vision model developed by Ultralytics, released in September 2024 under the AGPL-3.0 license. It is the latest generation in the Ultralytics YOLO series and supports object detection, instance segmentation, image classification, pose estimation, and oriented bounding box detection within a single unified framework. YOLO11 introduces architectural refinements that improve accuracy while reducing parameter count compared to YOLOv8 at equivalent model sizes.YOLO11 is available in five model sizes from Nano to Extra Large and is deployable through the Ultralytics Python package, Roboflow Inference, and export formats including ONNX, TensorRT, and CoreML. It supports fine-tuning on custom datasets through the standard Ultralytics training API.
YOLOv9
YOLOv9 is a real-time object detection model developed by Chien-Yao Wang and Hong-Yuan Mark Liao at Academia Sinica, released in February 2024 under the GPL-3.0 license. It introduces Programmable Gradient Information (PGI), a mechanism that preserves complete input information through auxiliary reversible branches during training to address information loss in deep network layers. It also introduces the Generalized Efficient Layer Aggregation Network (GELAN), which achieves better parameter utilization compared to prior CSP-based designs.YOLOv9-C achieves 53.0% AP on COCO with 42% fewer parameters and 21% less computation than YOLOv8-C at comparable accuracy. YOLOv9-E achieves 55.6% AP. The model is deployable through Roboflow Inference and supports fine-tuning via the standard training pipeline in the official repository.
RF-DETR
RF-DETR is a real-time transformer-based object detection model developed by Roboflow, with code and weights first released in March 2025 under the Apache 2.0 license. It is the first real-time model to exceed 60 AP on the Microsoft COCO benchmark, built on a DINOv2 vision transformer backbone with weight-sharing neural architecture search used to identify accuracy-latency trade-offs. The full family spans six sizes from Nano (30.5M parameters, 384×384 input) to 2XL (126.9M parameters, 880×880 input), with the accompanying research paper accepted to ICLR 2026.RF-DETR is designed for strong domain adaptability, achieving state-of-the-art performance on RF100-VL, a benchmark measuring generalization to real-world object detection tasks across diverse domains. It is deployable through Roboflow Inference and supports fine-tuning on custom datasets, making it well suited for domain-specific applications with limited training data.
YOLOv10
YOLOv10 is a real-time end-to-end object detection model developed by THU-MIG at Tsinghua University, released in May 2024 under the AGPL-3.0 license. It introduces consistent dual assignments during training — using both one-to-many and one-to-one label assignment strategies — to eliminate the need for non-maximum suppression at inference time while maintaining competitive accuracy. This end-to-end design reduces inference latency compared to NMS-dependent detectors at similar accuracy levels.YOLOv10-B achieves 52.7% AP on COCO with 46% lower latency than YOLOv9-C at comparable performance. The model is available in six sizes from Nano to Extra Large, built on the Ultralytics framework, and exportable to ONNX, TensorRT, and CoreML. YOLOv10 is suited for latency-sensitive deployment scenarios where post-processing overhead is a constraint.
YOLOv12
YOLOv12 is an attention-centric real-time object detection model developed by researchers at Tsinghua University, with the arXiv paper published in February 2025 under the AGPL-3.0 license. It introduces an Area Attention module that partitions feature maps into regions and applies self-attention within each region, reducing the quadratic complexity of full self-attention while capturing long-range dependencies. It also incorporates R-ELAN for improved feature aggregation and scaled residual connections for training stability.YOLOv12-L achieves 54.0% AP on COCO, while the YOLOv12-N variant achieves 40.5% mAP at 1.62ms latency on an NVIDIA T4 GPU. The model is built on the Ultralytics codebase, supporting detection, segmentation, and other standard YOLO tasks at competitive real-time speeds.

Deploy YOLOv8 with an API

YOLOv8 runs as a hosted REST endpoint through Roboflow Workflows. Pick a task, then hand the prompt to your coding agent or copy the code. Forking the workflow into a free Roboflow workspace replaces the your-workspace and YOUR_API_KEY placeholders with your own.

Connect your agent to Roboflow (once)

Add the Roboflow MCP server

claude mcp add --transport http roboflow https://mcp.roboflow.com/mcp

Run /mcp and authorize Roboflow in your browser when the OAuth flow opens.

Start a new Claude Code session so the MCP loads, then paste the prompt below (it works the same in any agent).

Fork this workflow to your Roboflow workspace to use it.

Integrate the Roboflow "YOLOv8" workflow into my app.

- Endpoint: POST https://serverless.roboflow.com/<your-workspace>/workflows/playground-yolov8-medium-1280-od-coco
- Auth: send my Roboflow API key as `api_key` in the request body, read from the ROBOFLOW_API_KEY env var (never hardcode).
- Body: { "api_key": ..., "inputs": { `image`: { type: "url" | "base64", value } } }.

With the Roboflow MCP connected, call `workflows_get` on "playground-yolov8-medium-1280-od-coco" to read the exact input schema (the source of truth), then `workflows_run` on a sample image to confirm the output shape before writing code (the MCP is authenticated, so this needs no key). Without the MCP, use the contract above.

Before running the app, set up these keys so it does not error at runtime:
- `ROBOFLOW_API_KEY` (sent as `api_key`) from https://app.roboflow.com/settings/api
Create a .gitignore'd .env with these variables, using placeholder values for any I haven't given you. Then pause and tell me directly, in your reply: the full path to the .env file, exactly which keys I need to paste in, and the link to get each one. Wait for me to confirm I've added them before you run anything. Do not run the app until I confirm.

Then add the integration to my codebase: match my project's language, framework, and conventions; read every key from environment variables (never hardcode); add basic error handling; and include a small runnable example. If you can't tell what language my project uses, ask me.
Installpip install inference-sdk

Fork this workflow to your Roboflow workspace to use it.

# 1. Import the library
from inference_sdk import InferenceHTTPClient

# 2. Connect to your workflow
client = InferenceHTTPClient(
  api_url="https://serverless.roboflow.com",
  api_key="YOUR_API_KEY"
)

# 3. Run your workflow on an image
result = client.run_workflow(
  workspace_name="your-workspace",
  workflow_id="playground-yolov8-medium-1280-od-coco",
  images={
    "image": "YOUR_IMAGE.jpg"  # Path to your image file
  },
  use_cache=True  # cache workflow definition for 15 minutes
)

# 4. Get your results
print(result)

Fork this workflow to your Roboflow workspace to use it.

const response = await fetch('https://serverless.roboflow.com/your-workspace/workflows/playground-yolov8-medium-1280-od-coco', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json'
  },
  body: JSON.stringify({
    api_key: 'YOUR_API_KEY',
    inputs: {
      "image": {"type": "url", "value": "IMAGE_URL"}
    }
  })
});

const result = await response.json();
console.log(result);

Fork this workflow to your Roboflow workspace to use it.

curl --location 'https://serverless.roboflow.com/your-workspace/workflows/playground-yolov8-medium-1280-od-coco' \
--header 'Content-Type: application/json' \
--data '{
  "api_key": "YOUR_API_KEY",
  "inputs": {
    "image": {"type": "url", "value": "IMAGE_URL"}
  }
}'

YOLOv8 License

AGPL-3.0

License terms and commercial-use guidance for YOLOv8.

YOLOv8 is licensed under an AGPL-3.0 license.

This means that YOLOv8 is available for private and commercial use, but that you will need to follow specific conditions. For commercial use, you need to follow AGPL-3.0 conditions or purchase a license for commercial use, modifications, and distribution.

Using an AGPL-3.0 licensed model is conditioned on making available complete source code of licensed works and modifications, which include larger works using a licensed work, under the same license. Copyright and license notices must be preserved. Contributors provide an express grant of patent rights. When a modified version is used to provide a service over a network, the complete source code of the modified version must be made available.

Read the full AGPL-3.0 license ↗

To use YOLOv8 in a commercial project without the AGPL-3.0 conditions, you need a license. As a paid Roboflow customer, you automatically get access to use any YOLOv8 models trained on or uploaded to our platform for commercial use. This is secured under Roboflow's sub-license agreement with Ultralytics, the creators of YOLOv8.

If you are a free Roboflow customer, you can use YOLOv8 in any way if using our serverless hosted API and can use YOLOv8 models commercially self-hosted with a paid plan.

To learn more about model licensing with Roboflow, refer to our Licensing guide.

AGPL-3.0 closes the "SaaS loophole" in GPL-3.0: even hosting the model behind an API counts as distribution and triggers the source-disclosure requirement.

License information is provided as a guide and is not legal advice.

Frequently Asked Questions About YOLOv8

YOLOv8 is a pretrained computer vision model for object detection. Unlike a general vision language model, it returns structured predictions for its task rather than free text.

YOLOv8 comes in 5 sizes: Nano (1280×1280), Small (1280×1280), Medium (1280×1280), Large (1280×1280), XL (1280×1280). Smaller variants run faster on constrained hardware; larger ones trade speed for accuracy. You can switch sizes in the demo to compare them on the same image.

Yes. The demo on this page runs YOLOv8 in the free Roboflow Playground: upload an image and see results in seconds. A free account unlocks unlimited runs.