Microsoft spent the past two years reselling other companies’ image models inside Azure. That changed on October 7, 2026, when Microsoft AI pushed its own MAI-Image-2.6 model into public preview inside Microsoft Foundry, the renamed and consolidated home for Azure AI Foundry’s model catalog. The company calls it “our strongest image model yet,” and it ships alongside a faster, cheaper sibling called MAI-Image-2.6-Flash.
If you build apps on Azure and you have been routing image requests to GPT Image or a third-party endpoint, MAI-Image-2.6 gives you a first-party option that lives in the same resource group as your other Microsoft Foundry deployments. This tutorial walks through the entire path: creating the right Azure resources, finding MAI-Image-2.6 in the model catalog, deploying it, authenticating against it, and calling it from both raw REST requests and a Python script you can reuse. By the end you will have a working command-line image generator, a clear picture of what MAI-Image-2.6 costs per image, and a troubleshooting table for the errors people are already hitting in preview.
What Is Microsoft Foundry’s MAI-Image-2.6, and Why It Matters
MAI-Image-2.6 is a diffusion-based image generation and editing model built by Microsoft AI’s in-house research group, not licensed from OpenAI or another lab, and it sits in the broader AI and machine learning landscape alongside the free consumer tool it will eventually replace inside Bing, covered in our Bing Image Creator setup guide. According to the model’s published card, the flagship version originally rolled out on August 14, 2026, with the Flash variant following on September 4, 2026. The broader developer release into Microsoft Foundry, the one most readers will actually touch, arrived on October 7, 2026, when Microsoft opened both models to Foundry projects as Global Standard deployments marked Preview.
Both models handle text-to-image generation and image-to-image editing from a single endpoint family. The model card lists a context length of 32,000 tokens, support for up to five JPEG or PNG reference images on editing calls, and a single PNG image as output per request. Neither model supports tool calling, and the only listed language is English. Microsoft’s launch post for the Foundry rollout describes MAI-Image-2.6 as landing on what the company calls the quality-cost frontier, meaning it claims a better result-per-dollar ratio than rival models rather than simply the highest raw quality score.
The practical reason to care: Microsoft Foundry already hosts your Azure OpenAI deployments, your Entra ID tenant, and your billing. Adding an image model from the same catalog means one resource, one API key rotation policy, and one invoice line instead of a separate vendor relationship. That is the pitch Microsoft is making to enterprise developers, and it is the reason searches for Microsoft Foundry have climbed sharply over the past two quarters as teams evaluate the platform for agentic and multimodal workloads. For a look at how a competing first-party image stack handles the same tradeoffs, see our walkthrough of migrating from Imagen 4 to Nano Banana 2 on the Gemini API.
Why Microsoft Built Its Own Image Model Instead of Reselling One
Azure OpenAI Service has carried GPT Image workloads for years, and Microsoft still resells models from other labs inside the Foundry catalog. MAI-Image-2.6 is different: it comes from Microsoft AI, the research group the company built up after years of leaning on its OpenAI partnership for frontier models. The MAI label already covers a growing family, including streaming transcription and text models, and the image line is the group’s most consumer-visible release yet.
The business logic is straightforward. Every dollar a customer spends calling a resold OpenAI model inside Azure flows, in part, back out to OpenAI under their commercial agreement. A dollar spent on MAI-Image-2.6 stays entirely inside Microsoft. That does not make MAI-Image-2.6 better or worse for your use case, but it explains why Microsoft is marketing a price-per-quality argument so aggressively in its launch material rather than leading with raw benchmark wins. The company needs enterprise developers to actively choose the in-house model over the familiar GPT Image option already sitting in the same catalog, and pricing is the lever it is pulling first.
There is also a timing angle worth noting. MAI-Image-2.6 reached developers one day after Google’s Nano Banana 2.1 went generally available on October 6, 2026, and roughly a month after OpenAI shipped GPT Image 2.5 on September 8, 2026. Three major labs refreshed their flagship image models within five weeks of each other heading into the final quarter of 2026, which is part of why “best ai image generator” searches have stayed volatile rather than settling on a single default answer the way they did in prior years.
Prerequisites: Accounts, Versions, and Costs Before You Start
Before you open the portal, line up the following. Skipping any of these is the single biggest reason a Microsoft Foundry deployment stalls at the “Updating” stage for an hour instead of a few minutes.
| Requirement | Minimum / Version | Notes |
|---|---|---|
| Azure subscription | Pay-As-You-Go or Enterprise Agreement | Free-tier/trial subscriptions frequently lack quota for Global Standard image deployments |
| Microsoft Foundry access | Current portal at ai.azure.com | Public preview models appear in the model catalog, not every tenant sees them immediately |
| Python | 3.10 or later | Needed for the azure-ai-inference SDK example later in this guide |
| azure-ai-inference SDK | Latest release on PyPI | Install with pip inside a virtual environment |
| Azure CLI | Latest release | Optional, useful for scripting resource and deployment creation |
| curl or Postman | Any current version | For the raw REST calls in Steps 10 through 12 |
| Region availability | Check before deploying | MAI-Image-2.6 is listed as a Global Standard deployment, available region list changes during preview |
| Budget for testing | A few dollars | Image output tokens are billed even in preview, see the pricing table below |
You do not need a GPU, a local model download, or a special enterprise agreement to follow this tutorial. MAI-Image-2.6 and MAI-Image-2.6-Flash are not self-hostable. Microsoft has not published open weights for either model, and the company’s documentation describes them strictly as Foundry Models sold by Azure, meaning the inference runs on Microsoft’s infrastructure and you pay per token or per image through your Azure bill. That is a meaningfully different setup from a locally-run checkpoint like the one covered in our Z-Image Turbo local setup guide, where the hardware requirement, not the account setup, is the real prerequisite.
MAI-Image-2.6 vs. MAI-Image-2.6-Flash: Picking the Right Model First
Microsoft ships two SKUs under the same family name, and picking the wrong one for your workload is an easy way to blow through a budget. MAI-Image-2.6 is the flagship: better text rendering inside images, stronger portraits, and more polished photorealistic output, according to Microsoft’s own model comparison. MAI-Image-2.6-Flash trades some of that ceiling for speed and a lower price, and Microsoft positions it for latency-sensitive, high-throughput production workloads, like generating many thumbnail variations in a batch job.
| Attribute | MAI-Image-2.6 | MAI-Image-2.6-Flash |
|---|---|---|
| Model version | 2026-07-31 | 2026-07-31 |
| Initial release | August 14, 2026 | September 4, 2026 |
| Deployment type | Global Standard | Global Standard |
| Text input price | $5 per 1M tokens | $1.75 per 1M tokens |
| Image input price | $8 per 1M tokens | $2.50 per 1M tokens |
| Image output price | $38 per 1M tokens | $19 per 1M tokens |
| Positioning | Flagship quality, text rendering, portraits | Lower cost, higher throughput, same editing scenarios |
| Max reference images | 5 (JPEG/PNG) | 5 (JPEG/PNG) |
| Output per request | 1 PNG image | 1 PNG image |
Independent benchmarking firm Artificial Analysis separately reported MAI-Image-2.6-Flash landing at roughly $19.50 per 1,000 output images on Microsoft Foundry, which does not map cleanly onto Microsoft’s own per-token figure because token counts vary with output resolution. Treat the two pricing structures as different units measuring the same bill, not as conflicting numbers. Artificial Analysis also placed MAI-Image-2.6-Flash at the number two spot on its image generation ranking shortly after launch, with both MAI models sitting on what the firm calls the Pareto frontier for quality versus price in image editing tasks.
For this tutorial, deploy both. The incremental cost of a second Global Standard deployment is zero until you actually send requests to it, and having both endpoints side by side makes it simple to compare quality against cost later.
Step 1: Create or Sign Into Your Azure Account
Go to the Azure portal and sign in with a work or personal Microsoft account. If you are starting fresh, set up a Pay-As-You-Go subscription rather than a free trial. Free trial subscriptions are routinely blocked from provisioning Global Standard deployments for newer preview models, and you will not find out until Step 6 fails with a quota error. Confirm your subscription is active under Subscriptions in the Azure portal before moving on.
Step 2: Open Microsoft Foundry and Create a Project
Navigate to ai.azure.com, which is the current home for the Microsoft Foundry portal. Select Create new, then choose a new Foundry project rather than a standalone Azure OpenAI resource. Foundry projects group your model deployments, connections, and evaluation tools in one workspace, and the MAI-Image models only appear inside that project-based catalog view, not in the older classic Azure OpenAI Studio resource list.
Name the project something you will recognize later, such as “mai-image-tutorial,” and pick a region. Microsoft has not published a fixed region allowlist for MAI-Image-2.6 as of this preview, so if your first region choice does not show the model in the catalog, try a second region before assuming your subscription is misconfigured.
Step 3: Set Up Billing and Request Quota
Inside your new project, open the Management or Quota section and confirm you have Global Standard quota available for image models. New subscriptions sometimes start at zero quota for newer model families until Microsoft’s automatic approval process runs, which can take anywhere from a few minutes to a business day. If you plan to run this tutorial as part of a scheduled demo, request quota a day in advance.
Step 4: Browse the Model Catalog for MAI-Image-2.6
From your Foundry project, click Model catalog in the left navigation, then search for MAI-Image-2.6. Filter by publisher if the catalog is large on your tenant, Microsoft lists both MAI models under the Microsoft publisher tag. You should see two catalog cards: MAI-Image-2.6 and MAI-Image-2.6-Flash, both tagged Preview and both showing version 2026-07-31.
Step 5: Review the Model Card Before Deploying
Open the MAI-Image-2.6 catalog entry and read the Foundry Models sold by Azure documentation alongside the model card tab. This is where Microsoft documents the 32,000-token context window, the five-image input limit for editing, the single-language English support, and the lack of tool calling. These limits matter for how you design your application later. If your product needs multilingual prompts, you will need to translate prompts into English before calling MAI-Image-2.6, since the model does not natively process other languages according to its published card.
Step 6: Deploy MAI-Image-2.6 as a Global Standard Endpoint
Click Deploy on the MAI-Image-2.6 catalog card. Choose Global Standard as the deployment type, since that is the only deployment type Microsoft currently lists for this model family. Give the deployment a name. This name is not necessarily the same string as the model ID, and that distinction causes a surprising number of integration bugs, covered in the pitfalls section below. A reasonable choice is mai-image-2-6-deploy, something short and unambiguous.
Confirm the deployment and wait. Preview model deployments in Microsoft Foundry typically move from Creating to Succeeded within a few minutes, though preview capacity constraints can push that longer during the first weeks after a launch like this one.
Step 7: Deploy MAI-Image-2.6-Flash Alongside It
Repeat Step 6 for MAI-Image-2.6-Flash, using a separate deployment name such as mai-image-2-6-flash-deploy. Running both deployments in the same project lets you route cheap, high-volume requests to Flash and reserve the flagship model for final-quality renders, a pattern this tutorial’s complete project implements later.
Step 8: Generate an API Key for Your Deployment
Open your deployment’s details page and find the Keys and Endpoint section. Microsoft Foundry issues a standard Azure resource API key here, sent with requests using an api-key header. Copy the endpoint URL and the primary key. Do not paste the key directly into application code. Store it as an environment variable instead:
export FOUNDRY_ENDPOINT="https://your-resource-name.region.inference.ai.azure.com"
export FOUNDRY_API_KEY="your-api-key-value"
export FOUNDRY_DEPLOYMENT="mai-image-2-6-deploy"Step 9: Configure Microsoft Entra ID Authentication (Optional, Recommended for Production)
API keys are fine for this tutorial, but production applications should prefer Microsoft Entra ID bearer authentication, which avoids storing a long-lived secret in your deployment pipeline. Register an application in Entra ID, grant it the Cognitive Services User role on your Foundry resource, and request a token through the standard OAuth client credentials flow. Requests then carry an Authorization header instead of an api-key header:
Authorization: Bearer <access-token>Microsoft’s documentation does not state whether every preview MAI-Image-2.6 deployment has both authentication methods enabled by default, so check your deployment’s Keys and Endpoint page for an Entra ID toggle before building this into a production path.
Step 10: Send Your First Text-to-Image Request
With your environment variables set, send a request to the image generations endpoint. The request body takes a prompt, a size, and a count of images to return:
curl -X POST
"$FOUNDRY_ENDPOINT/openai/deployments/$FOUNDRY_DEPLOYMENT/images/generations?api-version=2026-07-31"
-H "Content-Type: application/json"
-H "api-key: $FOUNDRY_API_KEY"
-d '{
"prompt": "A cinematic alpine lake at sunrise, ultra-detailed, soft light",
"size": "1024x1024",
"n": 1
}'A successful call returns a JSON payload containing a base64-encoded PNG or a short-lived URL to the generated image, depending on the response format configured on your deployment. Save that payload to disk before moving to the next step, since you will reuse the same pattern when building the full project later in this guide.
Step 11: Parse the Response and Save the Image
Pipe the previous call through a small script to decode and save the result locally:
import base64
import json
import sys
response = json.load(sys.stdin)
image_b64 = response["data"][0]["b64_json"]
with open("output.png", "wb") as f:
f.write(base64.b64decode(image_b64))
print("Saved output.png")Run the curl command from Step 10 piped into this script, and confirm output.png opens as a valid image. If it does not, jump to the troubleshooting table below before continuing, since a malformed response at this stage usually points to a deployment or region issue rather than a code bug.
Step 12: Edit an Existing Image With Up to Five Reference Images
MAI-Image-2.6’s editing capability is a separate API family from plain generation, and it accepts multipart form data rather than a JSON body, since you are uploading actual image files. The model card specifies a cap of five JPEG or PNG reference images per edit call:
curl -X POST
"$FOUNDRY_ENDPOINT/openai/deployments/$FOUNDRY_DEPLOYMENT/images/edits?api-version=2026-07-31"
-H "api-key: $FOUNDRY_API_KEY"
-F "prompt=Replace the cloudy sky with a vivid orange sunset, keep the lake unchanged"
-F "image[]=@reference_1.png"
-F "image[]=@reference_2.png"
-F "size=1024x1024"If you submit a sixth reference image, expect the request to fail validation rather than silently truncate to five. Check your upload logic if you are looping over a dynamic list of reference assets pulled from user input.
Step 13: Install the Azure AI Inference SDK and Call MAI-Image-2.6 From Python
Raw REST calls work for testing, but most production integrations use the azure-ai-inference Python package, documented in Microsoft’s guide to deploying and using MAI image models. Install the package inside a virtual environment:
python3 -m venv .venv
source .venv/bin/activate
pip install azure-ai-inference azure-coreThen wrap the generation call in a reusable function:
import os
import base64
from azure.core.credentials import AzureKeyCredential
from azure.ai.inference import ImageGenerationClient
endpoint = os.environ["FOUNDRY_ENDPOINT"]
api_key = os.environ["FOUNDRY_API_KEY"]
deployment = os.environ["FOUNDRY_DEPLOYMENT"]
client = ImageGenerationClient(
endpoint=endpoint,
credential=AzureKeyCredential(api_key),
)
def generate_image(prompt, size="1024x1024", out_path="output.png"):
result = client.generate(
deployment_name=deployment,
prompt=prompt,
size=size,
n=1,
)
image_bytes = base64.b64decode(result.data[0].b64_json)
with open(out_path, "wb") as f:
f.write(image_bytes)
return out_path
if __name__ == "__main__":
generate_image("A minimalist product shot of a ceramic mug on a white background")Treat the exact class and method names above as the representative Azure SDK pattern rather than a guaranteed final signature, since Microsoft had not published a complete, versioned SDK reference for MAI-Image-2.6 at the time of this preview rollout. Check the installed package’s own documentation strings with help(ImageGenerationClient) if a method name has shifted by the time you run this.
Complete Working Project: A Command-Line Batch Image Generator
With all 13 steps done, here is a complete script that reads prompts from a text file, routes short prompts to the cheaper Flash model and longer, detail-heavy prompts to the flagship model, and saves numbered output files. This is the kind of cost-aware routing pattern that makes running two deployments in Step 7 worthwhile.
import os
import base64
import sys
from azure.core.credentials import AzureKeyCredential
from azure.ai.inference import ImageGenerationClient
ENDPOINT = os.environ["FOUNDRY_ENDPOINT"]
API_KEY = os.environ["FOUNDRY_API_KEY"]
FLAGSHIP_DEPLOYMENT = "mai-image-2-6-deploy"
FLASH_DEPLOYMENT = "mai-image-2-6-flash-deploy"
LENGTH_THRESHOLD = 120
client = ImageGenerationClient(endpoint=ENDPOINT, credential=AzureKeyCredential(API_KEY))
def pick_deployment(prompt):
return FLAGSHIP_DEPLOYMENT if len(prompt) > LENGTH_THRESHOLD else FLASH_DEPLOYMENT
def generate(prompt, index):
deployment = pick_deployment(prompt)
result = client.generate(deployment_name=deployment, prompt=prompt, size="1024x1024", n=1)
image_bytes = base64.b64decode(result.data[0].b64_json)
filename = f"batch_output_{index:03d}_{deployment}.png"
with open(filename, "wb") as f:
f.write(image_bytes)
print(f"[{index}] {deployment} -> {filename}")
def main(prompt_file):
with open(prompt_file) as f:
prompts = [line.strip() for line in f if line.strip()]
for i, prompt in enumerate(prompts, start=1):
try:
generate(prompt, i)
except Exception as exc:
print(f"[{i}] FAILED: {exc}", file=sys.stderr)
if __name__ == "__main__":
main(sys.argv[1] if len(sys.argv) > 1 else "prompts.txt")Create a prompts.txt file with one prompt per line, run python batch_generate.py prompts.txt, and watch it route each line to the right deployment automatically. This single file is a reasonable starting point for a marketing team that needs dozens of product variations without paying flagship pricing for every single one.
Before you point this script at a real workload, run it against a short prompts file of three or four lines first. Confirm the output filenames show a mix of both deployment names, which tells you the length-based routing logic is actually firing instead of silently falling back to one model for every request. Open each saved PNG to confirm it is not a zero-byte file, a common symptom when a content filter silently blocks a generation without raising an exception your except block would catch. Once that short run looks correct, scale up to your real prompt list and watch the per-request print output for any FAILED lines, since those indicate a specific prompt tripped a validation or content rule worth inspecting individually rather than a systemic problem with your deployment.
Understanding MAI-Image-2.6 Pricing and Rate Limits
Microsoft bills MAI-Image-2.6 and MAI-Image-2.6-Flash by tokens, not by a flat per-image rate, which is unusual among image models and trips up developers who are used to a simple per-image price from competing services. The table below combines the official Microsoft Foundry pricing with the publicly reported preview rate limits for MAI Playground, the consumer-facing demo surface that predates the Foundry developer rollout.
| Metric | MAI-Image-2.6 | MAI-Image-2.6-Flash |
|---|---|---|
| Text input | $5 per 1M tokens | $1.75 per 1M tokens |
| Image input | $8 per 1M tokens | $2.50 per 1M tokens |
| Image output | $38 per 1M tokens | $19 per 1M tokens |
| Artificial Analysis reported rate (Flash) | Not applicable | ~$19.50 per 1,000 output images |
| MAI Playground rate limit (per user) | 2 requests/minute, 20 images/day | 2 requests/minute, 20 images/day |
| MAI Playground rate limit (per IP) | 3 requests/minute, 60 images/day | 3 requests/minute, 60 images/day |
Those Playground figures describe the public demo environment Microsoft uses for casual testing, not the production preview quota inside Microsoft Foundry deployments, which depends on your subscription tier and approved Global Standard capacity. Do not assume your Foundry deployment is capped at two requests a minute. It almost certainly is not, but Microsoft has not published a fixed production quota table for this preview, so run a small load test before committing a customer-facing feature to it.
For context, Google’s Nano Banana 2.1, which went generally available on October 6, 2026, one day before the MAI-Image-2.6 Foundry rollout, charges around $0.0336 for a standard 1K image and $0.0756 for a 4K image, according to pricing reported by Moneycontrol and Kingy AI. OpenAI’s GPT Image 2.5, released September 8, 2026, bills at $30 per million image output tokens across its Flare and Sunburst variants. Run your own cost comparison against your expected image dimensions before standardizing on any single provider, since token-based and per-image pricing do not translate one-to-one.
5 Common Pitfalls When Deploying MAI-Image-2.6
- Assuming the deployment name equals the model ID. Azure Global Standard deployments let you pick any name you want. If your code hardcodes “MAI-Image-2.6” as the deployment parameter but you named your deployment something else in Step 6, every call returns a 404.
- Mixing up the generations and edits endpoints. Microsoft documents these as two separate API families. Sending an edit payload with image attachments to the generations route, or a plain prompt to the edits route, fails validation rather than falling back gracefully.
- Testing production load against MAI Playground. The 2 requests-per-minute Playground limit exists for the public demo, not your Foundry deployment, but developers who start there assume the limit follows them into their own resource and under-provision for real traffic.
- Confusing token pricing with per-image pricing. Because MAI-Image-2.6 bills by image output tokens rather than a flat per-image fee, a batch of large 4K renders can cost meaningfully more than the same batch at 1024×1024, even though competing per-image-priced services would charge the same rate for both.
- Uploading more than five reference images to an edit call. The model card caps multi-reference editing at five JPEG or PNG images. Loops that pull a variable number of assets from a user-uploaded gallery need an explicit cap before the request goes out.
- Deploying in a region where the model has not propagated yet. Because this is a fresh preview rollout, the model catalog can show MAI-Image-2.6 as available in a region before deployment actually succeeds there. If a deployment hangs in “Creating” for more than fifteen minutes, try a different region rather than waiting it out.
Troubleshooting: 8 Common Microsoft Foundry Errors and Fixes
| Error or Symptom | Likely Cause | Fix |
|---|---|---|
| 401 Unauthorized | Wrong header name or expired key | Confirm you are sending api-key, not Authorization, unless you configured Entra ID. Rotate the key from the deployment page. |
| 404 Not Found on the deployment route | Deployment name mismatch | Check the exact deployment name on the Keys and Endpoint page, it is case-sensitive and may differ from the model ID. |
| 429 Too Many Requests | Exceeded your Foundry quota or hit Playground-style limits by mistake | Add exponential backoff, confirm you are calling your own deployment endpoint and not the public MAI Playground URL. |
| Deployment stuck on “Updating” | Regional capacity constraints during preview | Wait fifteen minutes, then delete and redeploy in a different supported region if it has not resolved. |
| Empty or null image data in response | Content filtering triggered silently | Rewrite the prompt to avoid flagged terms, check for a content_filter_results field in the raw response body. |
| Edit request rejected with a validation error | More than five reference images, or an unsupported file type | Confirm all images are JPEG or PNG and the array length is five or fewer before sending. |
| Model not visible in the catalog | Tenant or region has not received the preview rollout yet | Switch the Foundry project region, or check back within a few days as Microsoft expands preview access. |
| SDK method signature mismatch | azure-ai-inference package updated after this guide was written | Run pip install –upgrade azure-ai-inference and check help() on the client class for the current method names. |
Advanced Tips: Optimizing Cost, Latency, and Output Quality
Once the basic pipeline works, a few adjustments make a real difference in production. First, cache prompts and their resulting images aggressively if your application regenerates similar content, since MAI-Image-2.6’s token-based billing means repeated near-identical prompts cost real money every single time, unlike a flat-rate service where repetition is free after the first call.
Second, use the routing pattern from the complete project above, but tune the length threshold against your own test set rather than copying the 120-character cutoff verbatim. Short, simple prompts rarely benefit from the flagship model’s extra text-rendering and portrait quality, so sending them to Flash saves money without a visible quality drop in most product-image and icon use cases.
Third, for editing workflows, order your reference images deliberately. Microsoft’s documentation does not specify how the model weighs multiple references, but early preview testers report that the first one or two images in the array carry more influence over the final composition than later ones, so put your primary subject reference first.
Finally, build retry logic with jittered backoff rather than a fixed delay. Preview-stage models see uneven load as more tenants get access, and a fixed one-second retry can accidentally synchronize with other callers hitting the same regional capacity pool, making 429 errors worse rather than better. If you have already wired up backoff and key rotation for a different provider’s API, the same pattern from our Mistral Large 4 API setup guide carries over almost unchanged, since both are HTTPS endpoints billed per token.
How MAI-Image-2.6 Compares to Other Microsoft Foundry Catalog Models
MAI-Image-2.6 is not the only image option inside the Foundry catalog, and Microsoft’s own material leans on third-party leaderboard mentions rather than publishing a full internal comparison table. Artificial Analysis ranked MAI-Image-2.6-Flash at number three on its image generation leaderboard shortly after the Foundry launch, and placed both MAI models on its quality-versus-price frontier for image editing specifically. Microsoft separately claims MAI-Image-2.6 delivers the best price-per-Elo performance among models it benchmarked on its MAI-Image-2.6 model page, though the company has not published the underlying Elo table that would let outside developers verify that claim directly. Early hands-on coverage from Intelligent Living’s preview testing noted that MAI Playground remained the only public way to try the model before the Foundry developer rollout widened access.
If your Foundry project also has access to other catalog models from providers like OpenAI or Black Forest Labs, the practical move is to run the same ten or fifteen prompts across each deployment and compare output side by side, since published benchmark rankings rarely match the specific prompt style your product actually uses. The batch script in this tutorial’s complete project section is a reasonable starting point for that kind of internal comparison, you just need to add a third deployment variable and a loop over providers. If you have already benchmarked Nano Banana against GPT Image, our 13-step Nano Banana vs. GPT Image API benchmark walks through the same side-by-side methodology and is a reasonable template to extend with a third MAI-Image-2.6 column.
Monitoring, Logging, and Cost Alerts for Your Deployment
A preview model deployment is an easy thing to forget about once it works, and that is exactly how a runaway batch job or a misconfigured retry loop turns into a surprise invoice line. Set up a budget alert in Azure Cost Management scoped to your Foundry resource group before you run anything beyond a handful of test calls. A simple threshold, for example an alert at $20 and another at $100, gives you a early warning well before token-based billing on image output adds up across a few thousand requests.
Second, route your application logs through Azure Monitor or a simple structured log file rather than relying on print statements during development. At minimum, log the deployment name, the prompt length, the response status code, and the token usage fields Microsoft returns in each response payload. That log becomes the first thing you check when a 429 error shows up in production, since it tells you immediately whether you are hitting your own quota or a shared regional capacity limit.
Third, tag every deployment and resource with a consistent naming convention from day one. During preview, Microsoft Foundry’s catalog and documentation structure can shift between the time you write an integration and the time you revisit it months later. A clear tag like mai-image-2-6-preview-oct2026 on your deployment makes it obvious, when you eventually audit your Azure spend, which resources were built against this specific preview version and which ones need to be re-validated against a newer general-availability release.
Frequently Asked Questions
Is MAI-Image-2.6 free to use?
No. MAI-Image-2.6 and MAI-Image-2.6-Flash bill through your Azure subscription at $1.75 to $38 per million tokens depending on the model and whether the tokens are text input, image input, or image output. The only free access point is the limited MAI Playground demo, which caps users at 20 images per day.
What is the difference between MAI-Image-2.6 and MAI-Image-2.6-Flash?
MAI-Image-2.6 is the flagship model, tuned for stronger text rendering, portraits, and photorealistic detail. MAI-Image-2.6-Flash trades some of that quality ceiling for roughly half the price and faster response times, and Microsoft positions it for high-throughput, latency-sensitive production workloads.
Can I access MAI-Image-2.6 without an Azure subscription?
The only non-Azure access point Microsoft has published is the MAI Playground demo, which is rate-limited to 2 requests per minute and 20 images per day per authenticated user. Programmatic access through the API requires a Microsoft Foundry project inside an Azure subscription.
How much does MAI-Image-2.6 cost per image?
Microsoft bills by tokens rather than a flat per-image rate: $38 per million image output tokens for MAI-Image-2.6, or $19 per million for Flash. The actual dollar cost per image depends on output resolution, since larger images consume more output tokens.
Does MAI-Image-2.6 support languages other than English?
According to Microsoft’s published model card, English is the only listed supported language for both MAI-Image-2.6 and MAI-Image-2.6-Flash as of this preview. Translate prompts to English before sending them if your application serves other languages.
Can I self-host MAI-Image-2.6 or download its weights?
No. Microsoft has not released open weights for MAI-Image-2.6 or its Flash variant. Both are documented strictly as Foundry Models sold by Azure, meaning inference runs on Microsoft’s infrastructure and is billed through your Azure account.
How does MAI-Image-2.6 compare to Nano Banana 2.1 or GPT Image 2.5?
All three launched within roughly a month of each other in late 2026. Pricing structures differ enough that a direct dollar comparison depends heavily on your output resolution and call volume, since Nano Banana 2.1 and GPT Image 2.5 use different billing units than MAI-Image-2.6’s per-token model. Run your own side-by-side test with representative prompts before standardizing on one provider.
When will MAI-Image-2.6 leave public preview?
Microsoft has not announced a general availability date for MAI-Image-2.6 or MAI-Image-2.6-Flash as of this guide’s publication. Preview-stage models on Microsoft Foundry typically run for several months before a general availability announcement, but the company has not committed to a specific timeline for this model family.
