> ## Documentation Index > Fetch the complete documentation index at: https://hobbyist-e43fa225.mintlify.site/llms.txt > Use this file to discover all available pages before exploring further. # Instant access to models in Microsoft Foundry (preview) > Learn about instant access in Microsoft Foundry, which let you call any supported model by name without creating a deployment first. Instant access to models lets you call any supported model by name — no deployment required. Create a Foundry project, start coding, and use any available model immediately. ## Prerequisites * An Azure subscription. [Create one for free](https://azure.microsoft.com/free/). * Sign in to [Microsoft Foundry](https://ai.azure.com/?cid=learnDocs). Make sure the **New Foundry** toggle is on. These steps refer to **Foundry (new)**. * A Foundry project in **West US 3** (the only supported region for instant access during preview). If you need to create a project, see [Create a project](../how-to/create-projects). * The **Foundry User** role on the project or account. The Foundry RBAC roles were recently renamed. **Foundry User**, **Foundry Owner**, **Foundry Account Owner**, and **Foundry Project Manager** were previously named Azure AI User, Azure AI Owner, Azure AI Account Owner, and Azure AI Project Manager. You might still see the previous names in some places while the rename rolls out. The role IDs and core permissions are unchanged by the rename. ## Start using models instantly With instant access, the workflow is simple — use a supported instant model name in your code. No deployment needed. The same API, SDK, and client you already use for deployments works with instant access models. No second SDK, no separate client, no configuration changes. Support for instant access continues to expand over time. The exact set changes frequently. See [Supported models](#supported-models) for ways to see the full list. For the `model` parameter, use the instant access model name, such as `"gpt-5-mini"`, instead of a deployed model name. ```python theme={null} import os from dotenv import load_dotenv from azure.identity import DefaultAzureCredential from azure.ai.projects import AIProjectClient load_dotenv() print(f"Using PROJECT_ENDPOINT: {os.environ['PROJECT_ENDPOINT']}") print(f"Using MODEL_DEPLOYMENT_NAME: {os.environ['MODEL_DEPLOYMENT_NAME']}") project_client = AIProjectClient( endpoint=os.environ["PROJECT_ENDPOINT"], credential=DefaultAzureCredential(), ) openai_client = project_client.get_openai_client() response = openai_client.responses.create( model=os.environ["MODEL_DEPLOYMENT_NAME"], input="What is the size of France in square miles?", ) print(f"Response output: {response.output_text}") ``` # [C#](#tab/csharp) For the `model` parameter, use the instant access model name, such as `"gpt-5-mini"`, instead of a deployed model name. ```csharp theme={null} using Azure.AI.Projects; using Azure.AI.Projects.OpenAI; using Azure.Identity; using OpenAI.Responses; #pragma warning disable OPENAI001 string projectEndpoint = Environment.GetEnvironmentVariable("PROJECT_ENDPOINT") ?? throw new InvalidOperationException("Missing environment variable 'PROJECT_ENDPOINT'"); string modelDeploymentName = Environment.GetEnvironmentVariable("MODEL_DEPLOYMENT_NAME") ?? throw new InvalidOperationException("Missing environment variable 'MODEL_DEPLOYMENT_NAME'"); AIProjectClient projectClient = new(new Uri(projectEndpoint), new AzureCliCredential()); ProjectResponsesClient responseClient = projectClient.OpenAI.GetProjectResponsesClientForModel(modelDeploymentName); ResponseResult response = await responseClient.CreateResponseAsync("What is the size of France in square miles?"); Console.WriteLine(response.GetOutputText()); ``` For the `model` parameter, use the instant access model name, such as `"gpt-5-mini"`, instead of a deployed model name. ```typescript theme={null} import { DefaultAzureCredential } from "@azure/identity"; import { AIProjectClient } from "@azure/ai-projects"; import "dotenv/config"; const projectEndpoint = process.env["PROJECT_ENDPOINT"] || ""; const deploymentName = process.env["MODEL_DEPLOYMENT_NAME"] || ""; async function main(): Promise { const project = new AIProjectClient(projectEndpoint, new DefaultAzureCredential()); const openAIClient = project.getOpenAIClient(); const response = await openAIClient.responses.create({ model: deploymentName, input: "What is the size of France in square miles?", }); console.log(`Response output: ${response.output_text}`); } main().catch(console.error); ``` For the `model` parameter, use the instant access model name, such as `"gpt-5-mini"`, instead of a deployed model name. ```java theme={null} package com.azure.ai.agents; import com.azure.identity.DefaultAzureCredentialBuilder; import com.openai.models.responses.Response; import com.openai.models.responses.ResponseCreateParams; public class CreateResponse { public static void main(String[] args) { // Format: "https://resource_name.ai.azure.com/api/projects/project_name" String ProjectEndpoint = "your_project_endpoint"; // Create responses client to call Foundry API ResponsesClient responsesClient = new AgentsClientBuilder() .credential(new DefaultAzureCredentialBuilder().build()) .endpoint(ProjectEndpoint) .buildResponsesClient(); // Run a responses API call ResponseCreateParams responseRequest = new ResponseCreateParams.Builder() .input("What is the size of France in square miles?") .model("gpt-5-mini") .build(); Response response = responsesClient.getResponseService().create(responseRequest); System.out.println(response.output()); } } ``` For the `model` parameter, use the instant access model name, such as `"gpt-5-mini"`, instead of a deployed model name. Also replace `YOUR-FOUNDRY-RESOURCE-NAME` with your values: ```console theme={null} curl -X POST https://YOUR-FOUNDRY-RESOURCE-NAME.services.ai.azure.com/api/projects/YOUR-PROJECT-NAME/openai/responses?api-version=2025-11-15-preview \ -H "Content-Type: application/json" \ -H "Authorization: Bearer $AZURE_AI_AUTH_TOKEN" \ -d '{ "model": "gpt-4.1-mini", "input": "What is the size of France in square miles?" }' ``` 1. On the Home page of your project, select **Test in playground**. 2. Use the **Model** dropdown in the playground to switch among deployed and instant access models. ## Playground for instant access models To reach the playground for instant access models, use one of these paths: 1. From **Home**, select **Test in playground**. 2. From **Home**, select **Explore models** to go to the model catalog. Or, select **Discover** > **Models**. Either path opens the catalog. 3. From the model catalog, select an instant access model to view its details. 4. From an instant access model details page, select **Open playground**. 5. From a playground, use the **Model** dropdown to switch to other instant access or deployed models. Diagram of navigation paths from Home to Playground, including Catalog and Model routes. ### Why instant access matters * **Switch models by changing one string** — use any instant model name in the `model=` line, without creating or deleting deployments. * **Same API and SDK** — the same calls work for both instant access and deployments. * **Works with your dev tools** — instant access integrates with Foundry CLI, VS Code, and CI/CD pipelines the same way deployments do. Deployments aren't going away. They remain the right choice when you need reserved throughput, custom content filters, data residency, or advanced enterprise configurations. Instant access simplify the getting-started experience so that deployments become something you level up to, not a gate you must pass before you can use a model. ## Supported models New models support instant access by default when they're released. The product team considers support for additional models based on customer demand. The list grows over time, and examples of models you might see include: * `chat-gpt-latest` * `gpt-5.6-sol` * `gpt-5.5` * `gpt-5-mini` * `gpt-5.3-codex` To see all models that support instant access: 1. Open a project in **West US 3** in the new Foundry experience, 2. Select **Discover** in the upper-right navigation, then **Models** in the left pane. 3. In the model catalog, select **Instant** under **Development options** to view the available instant access models. You can also list instant access models programmatically: ```bash theme={null} SUBSCRIPTION_ID="" LOCATION="westus3" az rest --method get \ --url "https://management.azure.com/subscriptions/$SUBSCRIPTION_ID/providers/Microsoft.CognitiveServices/locations/$LOCATION/models?api-version=2025-06-01" \ --output json \ | jq -r '(.value // .models // .)[] | select((.model.capabilities.instant // "false" | tostring | ascii_downcase) == "true") | .model.name' \ | sort -u ``` During the preview, instant access models are available in projects in **West US 3** only. Some instant access models might appear in the list even if your subscription has no quota for them. For more information, see [Quotas and limits for Foundry Models](/models/quotas-limits). ## When to use instant access vs. deployments | Scenario | Recommended approach | | -------------------------------------------------------------------------------- | -------------------- | | Getting started, prototyping, or experimentation | Instant access | | Using the latest model immediately after release | Instant access | | Need reserved capacity or [predictable throughput](/models/deployment-types) | Deployment | | Require [provisioned throughput (PTU)](/models/provisioned-throughput) | Deployment | | Need [data residency](/models/deployment-types) in a specific region | Deployment | | Custom [content filtering](../guardrails/guardrails-overview) policies per model | Deployment | | Custom [guardrails](../guardrails/guardrails-overview) per model | Deployment | | Endpoint-specific configuration (for example, version locks per endpoint) | Deployment | | Fine-grained [quota](/models/quota) partitioning across teams | Deployment | | [Fine-tuned models](/models/fine-tune-cli) | Deployment | Instant access and deployments can coexist in the same project. You can start with instant access model and create a deployment later as your requirements evolve. ## Model versions By default, instant access uses the latest evergreen version of a model. To pin to a specific version, append the version date to the model name as a hyphenated suffix: | What you pass as `model` | Behavior | | ------------------------ | ------------------------------- | | `model-name` | Routes to the latest version | | `model-name-2025-04-01` | Routes to that specific version | Version pinning is opt-in. If your application requires stability, include the version suffix. Otherwise, you always get the latest version automatically. ## How quota is consumed Instant access draws from a per-model **global quota** pool assigned to your subscription. This quota is separate from the regional quota used by standard deployments. * You don't allocate or partition global quota — it's shared automatically across all instant model usage in your subscription. * Global Standard deployments reserve a portion of your global quota. Instant access models use whatever capacity remains. * Other deployment types (Regional Standard, Provisioned) use separate regional quota and don't affect your instant model capacity. * If instant model requests are throttled, you can request a quota increase or create a deployment with reserved capacity. For more details on how global and regional quotas interact, see [Manage and increase quotas](/models/quota). ## Enterprise controls | Capability | How it works | | ---------------------------------- | ----------------------------------------------------------------------------------------- | | Block specific models or providers | Azure Policy definitions apply to instant access the same way they apply to deployments | | Pin to a model version | Append the version suffix to the model name (see [Model versions](#model-versions)) | | Disable instant access entirely | Administrators can turn off instant access at the subscription level through Azure Policy | To remove instant access from an account, configure the settings through Bicep or ARM REST. Update your account with: ```http theme={null} PATCH https://management.azure.com/subscriptions/{sub}/resourceGroups/{rg}/providers/Microsoft.CognitiveServices/accounts/{account}?api-version=2026-01-15-preview Authorization: Bearer {arm_token} Content-Type: application/json ``` Use this request body to effectively shut off instant model access: ```json theme={null} { "properties": { "instant": { "raiPolicyName": "Microsoft.DefaultV2", "modelAllowList": [] } } } ``` Update your existing account resource with an `instant` block: ```bicep theme={null} resource account 'Microsoft.CognitiveServices/accounts@2026-01-15-preview' = { name: accountName location: location kind: 'AIServices' sku: { name: 'S0' } // Keep your existing account properties and add instant settings. properties: { instant: { raiPolicyName: 'Microsoft.DefaultV2' modelAllowList: [] } } } ``` All instant access models use default [guardrails](../guardrails/guardrails-overview) and content filters. However, you can't configure custom guardrails or Responsible AI (RAI) policies on a per-model basis for instant access. You can set a default RAI policy at the account level through the API, but that policy applies uniformly to all instant access models. If you need different content filtering policies for individual models, use a deployment. ## Deployment name collisions New deployments can't use a name that matches an existing model name. If you have an existing deployment whose name collides with a model name, the deployment takes precedence and instant model access for that model name is unavailable in that project. ## Limitations during preview * Available in **West US 3** only. * Fine-tuned models aren't supported. To use a fine-tuned model, create a deployment. * [Guardrails](../guardrails/guardrails-overview), custom RAI policies, and content filters aren't configurable for instant access. * Only the models listed in [Supported models](#supported-models) are eligible. ## Related content * [Deployment overview for Microsoft Foundry Models](/models/deployments-overview) * [Deployment types for Microsoft Foundry Models](/models/deployment-types) * [Manage quotas for Foundry resources](/models/quota) * [Microsoft Foundry quickstart](/get-started/get-started-code)