While Microsoft's documentation provides information on the OpenAI models available in Azure, it can be challenging to determine which features are included in which model versions and in which regions they are available. There can be occasional inaccuracies in the documentation. I believe this is the limitations of natural language documentation, thus I found that we should investigate directly within the actual Azure environment. This idea led to the creation of this article.
Introduction
While Microsoft's documentation provides information on the OpenAI models available in Azure, it can be challenging to determine which features are included in which model versions and in which regions they are available. There can be occasional inaccuracies in the documentation.
I believe this is the limitations of natural language documentation, thus I found that we should investigate directly within the actual Azure environment. This idea led to the creation of this article.
You need available Azure subscription, then you can retrieve a list of models available in a specific region using the az cognitiveservices model list command. This command allows you to query the Azure environment directly to obtain up-to-date information on available models. In the following sections, we'll explore how to analyze this data using various examples.
Please note that the PowerShell scripts in this article are intended to be run with PowerShell Core. If you execute them using Windows PowerShell, they might not function as expected.
Using Azure CLI to List Available AI Models
To begin, let's check what information can be retrieved. By executing the following command:
az cognitiveservices model list -l westus3You'll receive a JSON array containing details about each model available in the West US3 region. Here's a partial excerpt from the output:
PS C:\Users\xxxxx> az cognitiveservices model list -l westus3
[
{
"kind": "OpenAI",
"model": {
"baseModel": null,
"callRateLimit": null,
"capabilities": {
"audio": "true",
"scaleType": "Standard"
},
"deprecation": {
"fineTune": null,
"inference": "2025-03-01T00:00:00Z"
},
"finetuneCapabilities": null,
"format": "OpenAI",
"isDefaultVersion": true,
"lifecycleStatus": "Preview",
"maxCapacity": 9999,
"name": "tts",
"skus": [
{
"capacity": {
"default": 3,
"maximum": 9999,
"minimum": null,
"step": null
},
"deprecationDate": "2026-02-01T00:00:00+00:00",
"name": "Standard",
"rateLimits": [
{
"count": 1.0,
"key": "request",
"renewalPeriod": 60.0,
"rules": null
}
],
"usageName": "OpenAI.Standard.tts"
}
],
"source": null,
"systemData": {
"createdAt": "2023-11-20T00:00:00+00:00",
"createdBy": "Microsoft",
"createdByType": "Application",
"lastModifiedAt": "2023-11-20T00:00:00+00:00",
"lastModifiedBy": "Microsoft",
"lastModifiedByType": "Application"
},
"version": "001"
},
"skuName": "S0"
},
{
"kind": "OpenAI",
"model": {
"baseModel": null,
"callRateLimit": null,
"capabilities": {
"audio": "true",
"scaleType": "Standard"
},
"deprecation": {
"fineTune": null,
"inference": "2025-03-01T00:00:00Z"
},
"finetuneCapabilities": null,
"format": "OpenAI",
"isDefaultVersion": true,
"lifecycleStatus": "Preview",
"maxCapacity": 9999,
"name": "tts-hd",
"skus": [
{
"capacity": {
"default": 3,
"maximum": 9999,
"minimum": null,
"step": null
},
"deprecationDate": "2026-02-01T00:00:00+00:00",
"name": "Standard",
"rateLimits": [
{
"count": 1.0,
"key": "request",
"renewalPeriod": 60.0,
"rules": null
}
],
"usageName": "OpenAI.Standard.tts-hd"
}
],
"source": null,
"systemData": {
"createdAt": "2023-11-20T00:00:00+00:00",
"createdBy": "Microsoft",
"createdByType": "Application",
"lastModifiedAt": "2023-11-20T00:00:00+00:00",
"lastModifiedBy": "Microsoft",
"lastModifiedByType": "Application"
},
"version": "001"
},
"skuName": "S0"
},From the structure of the JSON output, we can derive the following insights:
- Model Information: Basic details about the model, such as model.format, model.name, and model.version, can be obtained from the format respectively.
- Available Capabilities: The model.capabilities field lists the functionalities supported by the model.
- Entries like chat-completion and completions indicate support for Chat Completion and text generation features.
- If a particular capability isn't supported by the model, it simply won't appear in the capabilities array. For example, if imageGeneration is not listed, it implies that the model doesn't support image generation.
- Deployment Information: Model's deployment options can be found in the model.skus field, which outlines the available SKUs for deploying the model.
- Service Type: The kind field indicates the type of service the model belongs to, such as OpenAI, MaaS, or other Azure AI services.
By querying each region and extracting the necessary information from the JSON response, we can effectively analyze and understand the availability and capabilities of Azure AI models across different regions.
Retrieving Azure AI Model Information Across All Regions
To gather model information across all Azure regions, you can utilize the Azure CLI in conjunction with PowerShell. Given the substantial volume of data and to avoid placing excessive load on Azure Resource Manager, it's advisable to retrieve and store data for each region separately. This approach allows for more manageable analysis based on the saved files.
While you can process JSON data using your preferred programming language, I personally prefer PowerShell. The following sample demonstrates how to execute Azure CLI commands within PowerShell to achieve this task.
# retrieve all Azure regions
$regions = az account list-locations --query [].name -o tsv
# Use this array if you retrive only specific regions
# $regions = @('westus3', 'eastus', 'swedencentral')
# retrieve all region model data and put as JSON file
$idx = 1
$regions | foreach {
$json = $null
write-host ("[{0:00}/{1:00}] Getting models for {2} " -f $idx++, $regions.Length, $_)
try {
$json = az cognitiveservices model list -l $_
} catch {
# skip some unavailable regions
write-host ("Error getting models for {0}: {1}" -f $_, $_.Exception.Message)
}
if($json -ne $null) {
$models = $json | ConvertFrom-Json
if($models.length -gt 0) {
$json | Out-File -FilePath "./models/$($_).json" -Encoding utf8
} else {
# skip empty array
Write-Host ("No models found for region: {0}" -f $_)
}
}
}Summarizing the Collected Data
Let's load the previously saved JSON files and count the number of models available in each Azure region. The following PowerShell script reads all .json files from the ./models directory, converts their contents into PowerShell objects, adds the region information based on the filename, and then groups the models by region to count them:
# Load all JSON files, convert to objects, and add region information
$models = Get-ChildItem -Path "./models" -Filter "*.json" | ForEach-Object {
$region = $_.BaseName
Get-Content -Path $_.FullName -Raw | ConvertFrom-Json | ForEach-Object {
$_ | Add-Member -NotePropertyName 'region' -NotePropertyValue $region -PassThru
}
}
# Group models by region and count them
$models | Group-Object -Property region | ForEach-Object {
Write-Host ("{0} models in {1}" -f $_.Count, $_.Name)
}This script will output the number of models available in each region. For example:
228 models in australiaeast
222 models in brazilsouth
206 models in canadacentral
222 models in canadaeast
89 models in centralus
...Which Models Are Deployable in Each Azure Region?
One of the first things you probably want is a list of which models and versions are available in each Azure region. The following script uses -ExpandProperty to unpack the model property array. Additionally, it expands the model.sku property to retrieve information about deployment models.
Please note that you have to remove ./model/global.json before running the following script.
# Since using 'select -ExpandProperty' modifies the original object, it’s a good idea to reload data from the files each time
Get-ChildItem -Path "./models" -Filter "*.json" `
| foreach {
Get-Content -Path $_.FullName `
| ConvertFrom-Json `
| Add-Member -NotePropertyName 'region' -NotePropertyValue $_.Name.Split(".")[0] -PassThru
} | sv models
# Expand model and model.skus, and extract relevant fields
$models
| select region, kind -ExpandProperty model `
| select region, kind, @{l='modelFormat';e={$_.format}}, @{l='modelName';e={$_.name}}, @{l='modelVersion'; e={$_.version}}, @{l='lifecycle';e={$_.lifecycleStatus}}, @{l='default';e={$_.isDefaultVersion}} -ExpandProperty skus `
| select region, kind, modelFormat, modelName, modelVersion, lifecycle, default, @{l='skuName';e={$_.name}}, @{l='deprecationDate ';e={$_.deprecationDate }} `
| sort-object region, kind, modelName, modelVersion `
| sv output
$output | Format-Table | Out-String -Width 4096
$output | Export-Csv -Path "modelList.csv" Given the volume of data, viewing it in Excel or a similar tool makes it easier to analyze.
Let’s ignore the fact that Excel might try to auto-convert model version numbers into dates—yes, that annoying behavior.
For example, if you filter for the gpt-4o model in the japaneast region, you’ll see that the latest version 2024-11-20 is now supported with the standard deployment SKU.
Listing Available Capabilities
While the model.capabilities property allows us to see which features each model supports, it doesn't include properties for unsupported features. This omission makes it challenging to determine all possible capabilities and apply appropriate filters. To address this, we'll aggregate the capabilities from all models across all regions to build a comprehensive dictionary of available features.
This approach will help us understand the full range of capabilities and facilitate more effective filtering and analysis.
# Read from files again
Get-ChildItem -Path "./models" -Filter "*.json" `
| foreach {
Get-Content -Path $_.FullName `
| ConvertFrom-Json `
| Add-Member -NotePropertyName 'region' -NotePropertyValue $_.Name.Split(".")[0] -PassThru
} | sv models
# list only unique capabilities
$models `
| select -ExpandProperty model `
| select -ExpandProperty capabilities `
| foreach { $_.psobject.properties.name} `
| select -Unique `
| sort-object `
| sv capability_dictionary The result is as follows:
allowProvisionedManagedCommitment
area
assistants
audio
chatCompletion
completion
embeddings
embeddingsMaxInputs
fineTune
FineTuneTokensMaxValue
FineTuneTokensMaxValuePerExample
imageGenerations
inference
jsonObjectResponse
jsonSchemaResponse
maxContextToken
maxOutputToken
maxStandardFinetuneDeploymentCount
maxTotalToken
realtime
responses
scaleType
searchCreating a Feature Support Matrix for Each Model
Now, let's use this list to build a feature support matrix that shows which capabilities are supported by each model. This matrix will help us understand the availability of features across different models and regions.
# Read from JSON files
Get-ChildItem -Path "./models" -Filter "*.json" `
| foreach {
Get-Content -Path $_.FullName `
| ConvertFrom-Json `
| Add-Member -NotePropertyName 'region' -NotePropertyValue $_.Name.Split(".")[0] -PassThru
} | sv models
# Outputting capability properties for each model (null if absent)
$models `
| select region, kind -ExpandProperty model `
| select region, kind, format, name, version -ExpandProperty capabilities `
| select (@('region', 'kind', 'format', 'name', 'version') + $capability_dictionary) `
| sort region, kind, format, name, version `
| sv model_capabilities
# output as csv file
$model_capabilities | Export-Csv -Path "modelCapabilities.csv"
Finding Models That Support Desired Capabilities
To identify models that support specific capabilities, such as imageGenerations, you can open the CSV file in Excel and filter accordingly. Upon doing so, you'll notice that support for image generation is quite limited across regions.
When examining models that support the Completion endpoint in the eastus region, you'll find names like ada, babbage, curie, and davinci. These familiar names bring back memories of earlier models. It also reminds that during the GPT-3.5 Turbo era, models supported both Chat Completion and Completion endpoints.
Conclusion
By retrieving data directly from the actual Azure environment rather than relying solely on documentation, you can ensure access to the most up-to-date information. In this article, we adopted an approach where necessary information was flattened and exported to a CSV file for examination in Excel. Once you're familiar with the underlying data structure, this method allows for investigations and analyses from various perspectives. As you become more accustomed to this process, it might prove faster than navigating through official documentation. However, for aspects like "capabilities," which may be somewhat intuitive yet lack clear definitions, it's advisable to contact Azure Support for detailed information.
Microsoft