Microsoft Azure AI Custom Vision Alternative: How to Migrate to Roboflow

Microsoft's Custom Vision Service will be retired on September 25, 2028. If you're looking for Microsoft Custom Vision alternatives, Roboflow stands out as the best choice for your Azure AI Custom Vision services migration. And now is the perfect time to migrate to a more flexible, future-proof platform.

Over Half the Fortune 100 Builds with Roboflow

Roboflow's end-to-end vision AI platform makes it easy to build, train, and deploy custom computer vision models, even if you’re not a machine learning expert. Here's what you can expect.

Faster Annotation & Better Data Tools

Roboflow offers model-assisted labeling to speed up annotation tasks and annotation heatmap visualization to better understand data distributions. Features like Smart Polygon let you annotate with a single click, and you can tap into 50,000+ pre-trained models from Roboflow Universe to auto-label your images.

True Platform Flexibility

Roboflow offers seamless integration with any tool and any workflow with no platform lock-in ever. Export your data in any format (COCO JSON, YOLO, Pascal VOC), and deploy to cloud and edge devices like NVIDIA Jetson, Raspberry Pi, or mobile devices for real-time inference. Your models and data stay portable.

Models That Improve Themselves

Roboflow's active learning feature re-annotates and re-trains low-confidence data, improving model performance over time. Your models get smarter automatically by learning from production data, creating a continuous improvement loop without manual intervention.

How to Move From Microsoft Custom Vision Service to Roboflow

Here's how to migrate from Microsoft Custom Vision Service to Roboflow in a few simple steps.

1. Get a COCO JSON Dataset

All we need to do to migrate to Roboflow is to get our dataset from Custom Vision in a compatible format. This page shows the compatible formats in Roboflow, and those tagged with “Import” are suitable for our use case here. We’ll be using COCO JSON since its quite quick to get the format.

Now, head over to the project settings of the model we’re going to migrate in the Custom Vision Portal.

Here, you’ll be able to access your API Key, Endpoint, and Project ID. These will be necessary for using the API, which we’ll use to extract the images and annotations from a Custom Vision project. Your screen should look something like the below, but with your specific project's details filled in.

Next, we’ll run a Python script to convert this data into COCO JSON Format. Create a new Python file and add the following snippet:

import os
import json
import requests
from datetime import datetime

# Configuration
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}

# Get tags
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}

# Get images
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

# Download images and prepare data
exported_data = []
for i, image in enumerate(images, 1):
    filename = f"image_{i:04d}.jpg"
    
    # Download
    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)
        
        # Store data
        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', [])]
        })

# Convert to COCO format
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

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

To use this code, be sure to replace your API key, Project ID, and Endpoint with the ones corresponding to your project settings. After running, we end up with a COCO JSON dataset:

Import COCO JSON Dataset into Roboflow

If you don’t have a project you’d like to migrate into, create a new project in Roboflow.

From here, all that's left is to upload our COCO JSON Dataset. This is why we chose this format, since its compatible for both export and import.

With that, we’ve successfully migrated to Roboflow. We can create new versions and train models super easily. 

With your data securely imported, you can train a new model in just a few clicks and deploy it anywhere - to the edge on devices like NVIDIA Jetson or Raspberry Pi, or to the cloud for scalable inference. Roboflow gives you full control, future-proof flexibility, and a faster path from dataset to production.

If you’d like personalized guidance on migrating your existing Azure Custom Vision workloads or optimizing your deployment pipeline, contact our AI experts, and we’ll help you make the transition seamless.

You might also be interested in learning how to run batch processing on images stored in Azure Blob.

Cite this Post

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

Contributing Writer. (Nov 7, 2025). Microsoft Azure AI Custom Vision Alternative: How to Migrate to Roboflow. Roboflow Blog: https://blog.roboflow.com/microsoft-azure-vision-alternative/