Azure Custom Vision Is Retiring: Deprecation Migration Guide

Microsoft is retiring the Azure AI Custom Vision service on September 25, 2028. After that date, calls to the Custom Vision training and prediction APIs will fail, and the Custom Vision portal will no longer be available. Microsoft advised customers to have a transition plan in place by September 25, 2026, a milestone that has already passed.

Here is what that means in practice. Models you exported in a compact domain (ONNX, CoreML, TensorFlow) will keep running on your devices after retirement. But you lose the ability to retrain them, the portal you labeled in, and managed access to your dataset. A model you cannot retrain is a model that degrades: lighting changes, products change, cameras move, and accuracy drifts with no way to recover it.

This guide covers every migration option, including the paths Microsoft recommends, and then walks through moving a Custom Vision project (dataset, labels, and a retrained model) to Roboflow step by step. The dataset migration takes about an afternoon.

Key Dates and Facts For Azure Custom Vision Deprecation

Microsoft's migration guidance shows:

Why Is Microsoft Retiring Custom Vision?

Custom Vision launched in preview at Build 2017 as part of Azure Cognitive Services, and for years it was the simplest way to train a custom image model on Azure: upload images, tag them, train, call an endpoint. The retirement is part of Microsoft's broader consolidation of Cognitive Services into the Foundry platform, where investment is shifting toward generative and multimodal models. That context matters for your migration choice: the products replacing Custom Vision are not simpler versions of it, they are different products with different priorities.

Your Azure Custom Vision Alternatives and Migration Options

There are three realistic paths: stay on Azure with a heavier tool, rebuild on another cloud's equivalent, or move to a dedicated computer vision platform.

Staying on Azure

Azure Machine Learning AutoML is Microsoft's recommended path for teams that want to keep training classic classification and object detection models. It is more capable than Custom Vision and sits inside a full MLOps framework, but it is a different product in kind: a code-first SDK workflow with compute clusters to configure and manage. The simplicity that made Custom Vision useful (upload, label, train, call an endpoint) is what you give up.

Microsoft also points to generative approaches: vision language models from the Foundry model catalog, and Azure Content Understanding (in preview) for managed classification workflows. These are worth evaluating if your task is flexible, like describing scenes or extracting document fields. For deterministic, high-accuracy detection on your own objects (defects, parts, products), a trained detection model still wins on accuracy, latency, and cost per inference.

One more data point for your platform-risk calculus: Image Analysis 4.0 model customization, previously positioned as the next generation of Custom Vision, carries its own deprecation notice. Teams migrating within Azure should confirm the longevity of whichever target they pick.

Other cloud AutoML services

Amazon Rekognition Custom Labels and Google Vertex AI offer comparable train-on-your-images services. Both are credible if you are already committed to that cloud. Note that Rekognition does not let you export trained model weights for on-device deployment, and Google has been consolidating its AutoML products into Vertex AI, with its own history of migrations. If the lesson of the Custom Vision retirement is that a vision workload should not be coupled to one cloud's product roadmap, rebuilding inside another cloud's equivalent service repeats the bet.

A dedicated Vision AI platform

Roboflow is built for exactly the workload Custom Vision served: teams training custom classification and object detection models without standing up ML infrastructure. The workflow maps one-to-one (upload, label, train, deploy to an API or a device), and the surrounding platform goes further than Custom Vision did: AI-assisted labeling, active learning, Workflows for chaining models and logic into applications, and deployment to cloud, edge, or fully on-prem. More than 1 million engineers and over half of the Fortune 100 build with Roboflow, and the platform powers over 55 billion inferences a year in production.

Comparison at a glance

Custom Vision to Roboflow: How the Concepts Map

Most migration anxiety is about mental models, not data. Here is the translation table.

Follow the steps below to easily migrate from Azure Custom Vision to Roboflow.

Step 1: Export your dataset from Custom Vision

Custom Vision's export feature covers trained models, not datasets. To get your images and labels out, use the training API. In the Custom Vision portal, open your project settings and copy your API key, endpoint, and project ID.

Object detection projects

The script below downloads every tagged image and converts the regions to COCO JSON, which imports directly into Roboflow (and into most other tools, if you go a different direction).

import os
import json
import requests
from datetime import datetime

ENDPOINT = "YOUR_ENDPOINT"
TRAINING_KEY = "YOUR_API_KEY"
PROJECT_ID = "YOUR_PROJECT_ID"
OUTPUT_DIR = "roboflow_coco"
IMAGES_DIR = os.path.join(OUTPUT_DIR, "images")

os.makedirs(IMAGES_DIR, exist_ok=True)
headers = {"Training-Key": TRAINING_KEY}

tags = requests.get(f"{ENDPOINT}customvision/v3.3/Training/projects/{PROJECT_ID}/tags", headers=headers).json()

images = []
skip = 0
while True:
    batch = requests.get(
        f"{ENDPOINT}customvision/v3.3/Training/projects/{PROJECT_ID}/images/tagged",
        headers=headers,
        params={"take": 50, "skip": skip}
    ).json()
    if not batch:
        break
    images.extend(batch)
    skip += 50

exported_data = []
for i, image in enumerate(images, 1):
    filename = f"image_{i:04d}.jpg"
    response = requests.get(image['originalImageUri'], headers=headers, stream=True)
    if response.status_code == 200:
        with open(os.path.join(IMAGES_DIR, filename), 'wb') as f:
            for chunk in response.iter_content(8192):
                f.write(chunk)
        exported_data.append({
            'filename': filename,
            'width': image['width'],
            'height': image['height'],
            'regions': [{
                'tagId': r['tagId'],
                'left': r['left'],
                'top': r['top'],
                'width': r['width'],
                'height': r['height']
            } for r in image.get('regions', [])]
        })

coco = {
    "info": {"description": "Exported from Azure Custom Vision", "date_created": datetime.now().isoformat()},
    "categories": [{"id": i+1, "name": tag["name"], "supercategory": "object"} for i, tag in enumerate(tags)],
    "images": [],
    "annotations": []
}

tag_id_to_coco = {tag['id']: i+1 for i, tag in enumerate(tags)}
annotation_id = 1

for img_idx, img in enumerate(exported_data, 1):
    coco["images"].append({
        "id": img_idx,
        "file_name": img['filename'],
        "width": img['width'],
        "height": img['height']
    })
    for region in img['regions']:
        left = region['left'] * img['width']
        top = region['top'] * img['height']
        width = region['width'] * img['width']
        height = region['height'] * img['height']
        coco["annotations"].append({
            "id": annotation_id,
            "image_id": img_idx,
            "category_id": tag_id_to_coco[region['tagId']],
            "bbox": [left, top, width, height],
            "area": width * height,
            "iscrowd": 0
        })
        annotation_id += 1

with open(os.path.join(OUTPUT_DIR, "annotations_coco.json"), 'w') as f:
    json.dump(coco, f, indent=2)

Note that images appearing in the images list with no annotation entries are treated as null examples (images with no objects of interest), which is valid COCO and imports cleanly.

Classification projects

Classification projects have tags but no regions, so the simplest portable format is a folder per class. This script downloads each image into a directory named for its tag:

import os
import requests

ENDPOINT = "YOUR_ENDPOINT"
TRAINING_KEY = "YOUR_API_KEY"
PROJECT_ID = "YOUR_PROJECT_ID"
OUTPUT_DIR = "classification_export"

headers = {"Training-Key": TRAINING_KEY}

tags = requests.get(f"{ENDPOINT}customvision/v3.3/Training/projects/{PROJECT_ID}/tags", headers=headers).json()
tag_map = {tag['id']: tag['name'] for tag in tags}

images = []
skip = 0
while True:
    batch = requests.get(
        f"{ENDPOINT}customvision/v3.3/Training/projects/{PROJECT_ID}/images/tagged",
        headers=headers,
        params={"take": 50, "skip": skip}
    ).json()
    if not batch:
        break
    images.extend(batch)
    skip += 50

for i, image in enumerate(images, 1):
    tag_names = [tag_map[t['tagId']] for t in image.get('tags', [])]
    if not tag_names:
        continue
    class_dir = os.path.join(OUTPUT_DIR, tag_names[0])
    os.makedirs(class_dir, exist_ok=True)
    response = requests.get(image['originalImageUri'], headers=headers, stream=True)
    if response.status_code == 200:
        with open(os.path.join(class_dir, f"image_{i:04d}.jpg"), 'wb') as f:
            for chunk in response.iter_content(8192):
                f.write(chunk)

Roboflow imports folder-per-class classification datasets directly. If you prefer existing tooling over scripts, the open-source projects Coco2CustomVision and cvsutils export Custom Vision projects too.

Whichever platform you end up on, run this export soon. The training API goes away with the service, and after September 25, 2028 there is no way to retrieve your labeled data.

Step 2: Import into Roboflow and retrain

Create a free Roboflow account and a new project, then drag in your COCO JSON folder (or classification folders). Annotations are detected automatically; Roboflow supports COCO JSON, Pascal VOC XML, and 30+ other formats.

Once the data is in, generate a dataset version and train. For object detection, train RF-DETR, a real-time detection architecture that will generally outperform the models Custom Vision trained, with evaluation metrics (mAP, precision, recall) on every version so you can compare against the numbers in your old Performance tab.

Migration is also a natural moment to upgrade. Custom Vision only ever offered classification and object detection, so teams that approximated segmentation tasks with bounding boxes can move to real instance segmentation here: relabel with Smart Polygon (one click per object) and train Roboflow's RF-DETR-Seg for pixel-precise masks instead of boxes.

Two things your Custom Vision workflow did not have are worth turning on from day one. Label Assist uses your trained model to pre-annotate new images, so labeling gets faster as the model improves. Active learning samples low-confidence images from production back into your dataset, so the model improves from the exact conditions it runs in. That closes the loop the retirement broke: instead of a frozen exported model, you get one that compounds.

Step 3: Re-create your deployment (including edge and offline)

If you called the Custom Vision prediction API, the swap is a hosted inference endpoint or a Workflow, which also lets you add logic (zones, counting, tracking, alerts) without extra code.

If you exported compact models to run on devices, this is where the migration is an upgrade rather than a rebuild. Roboflow Inference is an open-source, production-grade inference server. Run the roboflow/roboflow-inference-server-gpu Docker container on an NVIDIA Jetson, an industrial PC, or any GPU machine, and your model runs locally, fully offline, with the same API surface as the hosted endpoint. No internet outage stops the line. When you retrain, you pull a new model version instead of hand-carrying an ONNX file to every device.

Frequently asked questions

When will Azure Custom Vision be deprecated?

September 25, 2028. After that date, calls to the training and prediction APIs fail. Microsoft advised customers to have a transition plan by September 25, 2026.

Will my exported models stop working?

No. Models exported in a compact domain (ONNX, CoreML, TensorFlow) keep running on your devices. But you lose retraining, the portal, and API access to your dataset, so accuracy drift becomes permanent.

Can I export my dataset and labels from Custom Vision?

Yes, while the service is live, via the training API (scripts above). The portal's export feature only covers trained models, not data.

What does Microsoft recommend migrating to?

Azure Machine Learning AutoML for classic classification and detection models, or generative approaches via the Foundry model catalog and Azure Content Understanding. Both are covered in the comparison above.

What is the best Custom Vision alternative for object detection?

For teams that chose Custom Vision for its workflow (upload, label, train, deploy without ML infrastructure), Roboflow is the closest match and extends it with AI-assisted labeling, RF-DETR training, active learning, and edge deployment. Teams wanting to stay inside Azure with a code-first workflow should evaluate Azure ML AutoML.

How long does migration take?

Exporting and importing a typical dataset takes an afternoon. Retraining and validating against your old metrics typically takes a day. Production cutover depends on your deployment, and our team helps enterprises plan it.

Start Now, Not in 2028

The deadline is years away, but the math favors moving early: your dataset is retrievable today, your model keeps improving from the day you retrain it, and you stop accumulating work on a platform that is going away. Import your dataset and train a model free, or if you are migrating production workloads across facilities, talk to our team. We have moved teams off retiring cloud vision services before, and we will help you scope the transition end to end.

Cite this Post

Use the following entry to cite this post in your research:

Aryan Vasudevan. (May 1, 2026). Azure Custom Vision Is Retiring: Deprecation Migration Guide. Roboflow Blog: https://blog.roboflow.com/azure-custom-vision-deprecation/