Introduction

In today’s enterprise landscape, enabling AI agents to interact with backend systems securely and at scale is critical. By exposing MCP servers through Azure API Management (APIM), organizations can provide controlled access to these services. When combined with OAuth 2.0 authorization code flow, this setup ensures robust, enterprise-grade security for AI agents built in Copilot Studio—empowering intelligent automation while maintaining strict access governance.

Disclaimer & Caveats

This article explores how to configure a MCP tool—exposed as a MCP server via APIM—for secure consumption by AI agents built in Copilot Studio. Leveraging the OAuth 2.0 Authorization Code Flow, this setup ensures enterprise-grade security by enabling delegated access without exposing user credentials.

With Azure API Management now supporting MCP server capabilities in public preview, developers can expose REST APIs as MCP tools using a standardized JSON-RPC interface. This allows AI agents to invoke backend services securely and scalable, without the need to rebuild existing APIs. Copilot Studio, also in preview for MCP integration, empowers organizations to orchestrate intelligent agents that interact with these tools in real time.

While this guide provides a foundational approach, every environment is unique. You can enhance security further by implementing app roles, conditional access policies, and extending your integration logic with custom Python code for advanced scenarios.

⚠️ Note: Both MCP server support in APIM and MCP tool integration in Copilot Studio are currently in public preview. As these platforms evolve rapidly, expect changes and improvements over time. Always refer to the https://learn.microsoft.com/en-us/azure/api-management/export-rest-mcp-server for the latest updates. 

This article is about consuming remote MCP servers. In Azure, managed identity can also be leveraged for APIM integration.

What is Authorization Code Flow?

The Authorization Code Flow is designed for applications that can securely store a client secret (like server-side apps). It allows the app to obtain an access token on behalf of the user without exposing their credentials. This flow uses an intermediate authorization code to exchange for tokens, adding an extra layer of security.

Steps in the Flow

1. User Authentication
   The user is redirected to the Authorization Server (In this case: Azure AD) to log in and grant consent.


2. Authorization Code Issued
   After successful login, the Authorization Server sends an authorization code to the app via the redirect URI.


3. Token Exchange
   The app sends the authorization code (plus client credentials) to the Token Endpoint to get: Access Token (for API calls) and Refresh Token (to renew access without user interaction)


4. API Access
   The app uses the Access Token to call protected resources.

Below diagram shows the Authorization code flow in detail.

Press enter or click to view image in full size

 

 

Microsoft identity platform and OAuth 2.0 authorization code flow — Microsoft identity platform | Microsoft Learn

 

High Level Architecture

Press enter or click to view image in full size

This architecture can also be implemented with APIM backend app registration only. However, stay cautious in configuring redirect URIs appropriately.

Remote MCP Servers using APIM Architecture

APIM exposing Remote MCP servers, enabling AI agents—such as those built in Copilot Studio—to securely access backend services using standardized JSON-RPC interfaces. This integration offers a robust, scalable, and secure way to connect AI tools with enterprise APIs.

Key Capabilities:

• Secure Gateway: APIM acts as an intelligent gateway, handling OAuth 2.0 Authorization Code Flow, authentication, and request routing.


• Monitoring & Observability: Integration with Azure Log Analytics and Application Insights enables deep visibility into API usage, performance, and errors.


• Policy Enforcement: APIM’s policy engine allows for custom rules, including token validation, header manipulation, and response transformation.


• Rate Limiting & Throttling: Built-in support for rate limits, quotas, and IP filtering helps protect backend services from abuse and ensures fair usage.


• Managed Identity & Entra ID: Secure service-to-service communication is enabled via system-assigned and user-assigned managed identities, with Entra ID handling identity and access management.


• Flexible Deployment: MCP servers can be hosted in Azure Functions, App Services, or Container Apps, and exposed via APIM with minimal changes to existing APIs.

To learn more, visit https://learn.microsoft.com/en-us/samples/azure-samples/remote-mcp-apim-functions-python/remote-mcp-apim-functions-python/

Develop MCP server in VS Code

This deployment guide provides sample MCP code written in python for ease of use. It is available on the following GitHub repo. However, you can also use your own MCP server.

Clone the following repository and open in VS Code.

git clone https://github.com/mafzal786/mcp-server.git Run the following to execute it locally. cd mcp-server uv venv uv sync uv run mcpserver.py

Deploy MCP Server as Azure Container App

In this deployment guide, MCP server is deployed in Azure Container App. It can also be deployed as Azure App service.

Deploy the MCP server in Azure container App by running the following command. It can be deployed by many other various ways such as via VS Code or CI/CD pipeline. AZ Cli is used for simplicity.

az containerapp up –resource-group –name streamable-mcp-server2 –environment mcp –location –source .

Configure Authentication for Azure Container App

1. Sign in Azure portal. Visit the container App in Azure and Click “Authentication” as shown below.

Press enter or click to view image in full size

 

 

For more details, visit the following link: Enable authentication and authorization in Azure Container Apps with Microsoft Entra ID | Microsoft Learn

Click Add Identity Provider as shown.

 

 

 

2. Select Microsoft from the drop down and leave everything as is as shown below.

 

 

 

3. This will create a new app registration for the container App. After it is all setup, it will look like as below.

 

As soon as authentication is configured. it will make container app inaccessible except for OAuth.

Note: If you have app registration for Azure Container App already configured, use that by selecting “pick an existing app registration in this directory” option.

Review App Registration of Container App — Backend

• Visit App registration and click streamable-mcp-server2 as in this case.


• Click on Authentication tab. Verify the Redirect URIs. you should see a redirect URL for container app. URI will end with /.auth/login/aad/callback as shown in the green box in the below screenshot.

 

 

• Now click on “Expose an API”. Confirm Application ID URI is configured with scope as shown below. its format is api://


• Scope “user_impersonation” is created.

 

 

• Verify API Permission. Make sure you Grant admin consent for your tenant as shown below. More scope can be created depending on the requirement of data access.

 

Note: Make sure to “Grant admin consent” before proceeding to next step.

Create App registration for representing APIM API

1.  Lauch Azure Portal. Visit App registration. Click New registration.
   

    

   
   


2. Create a new App registration as shown below. For example, “apim-mcp-backend-api” in this case.
   

    

   
   


3. Click “Expose an API“, configure Application ID URI, and add a scope as shown in the below diagram such as user_impersonation.
   

    

   
   


4. Click “App roles” and create the following role as shown below. More roles can be created depending on the requirements and case by case basis. Here app roles are created to get the concept around it and how it will be used in APIM inbound policies in the coming sections.
   

    

   
   

Create App Registration for Client App — Copilot Studio

In these steps, we will be configuring app registration for the client app, such as copilot studio in this case acting as a client app. This is also mentioned in the “high level architecture” diagram in the earlier section of this article.

1. Lauch Azure Portal. Visit App registration. Click New registration.

1. Create a new App registration. leave the Redirect URL as of now, we will configure it later as it is provided by copilot studio when configuring custom MCP connector.

3. Click on API permission and click “Add a permission”. Click Microsoft Graph and then click “Delegated permissions”. Select email, openid, profile as shown below.

 

 

4. Make sure to Grant admin consent and it should look like as below.

 

5. Create a secret. click “Certificates & secrets”. Create a new client secret by clicking “New client secret”. store the value as it will be masked after some time. if that happens, you can always delete and re-create a new secret.

6. Capture the following as you would need it in configuring MCP tool in Copilot Studio.

• Client ID from the Overview Tab of app registration.

• Client secret from “Certificates & secrets” tab.

7. Configure API permissions for APIM API i.e. “apim-mcp-backend-api” in this case. Click “API permissions” tab. Click “Add a permission”. Click on “My APIs” tab as shown below and select “apim-mcp-backend-api“.

Note: If you don’t see the app registration in “My APIs”. Go to App registration. Click “Owners”. Add your AD account as Owners.

 

8. Select “Delegated permissions“. Then select the permission as shown below.

9. Select the Application permission. Select the App roles created in the apim-mcp-backend-api registration. Such as mcp.read in this case.

You MUST “Grant admin consent” as final step. It is very important!!! I can’t emphasize more on that. without it, nothing will work!!!

10. End result of this client app registration should look like as mentioned in the below figure.

Configure permissions for Container App registration 

1. Lauch Azure Portal. Visit app registration.


2. Select app registration of Azure container app such as streamable-mcp-server2 in this case.


3. Select API permissions.


4. Add the following delegated and application permissions as shown in the below diagram.

 

Note: Don’t forget to Grant admin consent.

Configure allowed token audience for Container App

It defines which audience values (aud claim) in a token are considered valid for your app. When a client app requests an access token from Microsoft Entra ID (Azure AD), the token includes an aud claim that identifies the intended recipient. Your container app will only accept tokens where the aud claim matches one of the values in the Allowed Token Audiences list.

This is important as it ensures that only tokens issued for your API or app are accepted and prevents misuse of tokens intended for other resources. This adds extra layer of security.

1. In the Azure Portal, visit Azure Container App. i.e. streamable-mcp-server2.


2. Click on “Authentication“


3. Click “Edit” under identity provider


4. Under “Allowed token audiences“, add the application ID URI of “apim-mcp-backend-api”. As this will be included as an audience in the access token.

 

Best Practices

• Only include trusted client app IDs.


• Avoid using overly broad values like “allow all” (not recommended).


• Validate tokens using Microsoft libraries (MSAL) or built-in auth features.

Configure MCP server in API Management

Note: Provisioning an API Management resource is outside the scope of this document.

If you do not already have an API Management instance, follow this QuickStart: https://learn.microsoft.com/en-us/azure/api-management/get-started-create-service-instance

The following service tiers are available for preview: Classic Basic, Standard, Premium, and Basic v2, Standard v2, Premium v2.

For the Classic Basic, Standard, or Premium tiers, you must join the AI Gateway Early Update group to enable MCP server features. Please allow up to 2 hours for the update to take effect.

Expose an existing MCP server

Follow these steps to expose an existing MCP server is API Management:

1. In the Azure portal, navigate to your API Management instance.


2. In the left-hand menu, under APIs, select MCP servers > + Create MCP server.


3. Select Expose an existing MCP server.


4. In Backend MCP server:
   
   
   
   1. Enter the existing MCP server base URL. Example: https://streamable-mcp-serverv2.kdhg489457dslkjgn,.eastus2.azurecontainerapps.io/mcpfor the Microsoft Azure Container App hosting MCP server.
   
   
   2. In Transport type, Streamable HTTP is selected by default.
   
   
   
   


5. In New MCP server:
   
   
   
   1. Enter a Name the MCP server in API Management.
   
   
   2. In Base path, enter a route prefix for tools. Example: mcptools
   
   
   3. Optionally, enter a Description for the MCP server.
   
   
   
   


6. Select Create.

Below diagram shows the MCP servers configured in APIM for reference.

 

 

Configure policies for MCP server

Configure one or more API Management policies to help manage the MCP server. The policies are applied to all API operations exposed as tools in the MCP server and can be used to control access, authentication, and other aspects of the tools.

To configure policies for the MCP server:

1. In the Azure portal, navigate to your API Management instance.


2. In the left-hand menu, under APIs, select MCP Servers.


3. Select an MCP server from the list.


4. In the left menu, under MCP, select Policies.


5. In the policy editor, add or edit the policies you want to apply to the MCP server’s tools. The policies are defined in XML format. 

 

<!–
– Policies are applied in the order they appear.
– Position inside a section to inherit policies from the outer scope.
– Comments within policies are not preserved.
–>
<!– Add policies as children to the , , , and elements –>

@(“Access Token: ” + (string)context.Variables[“accessToken”])

@(“username: ” + (string)context.Variables[“userName”])

@(“scope: ” + (string)context.Variables[“scp”])

@(“Roles: ” + (string)context.Variables[“roles”])

<!–
<set-variable name="requestBody" value="@{
return context.Request.Body.As(preserveContent:true);
}” />

@(“Request body: ” + (string)context.Variables[“requestBody”])

–>

{{client-application-id}}

{{audience}}

mcp.read

@(“username: ” + (string)context.Variables[“userName”] + ” has error in accessing the MCP server, could be auth or role related…”)

{“error”:”Missing required scope or role”}

 

Note: Update the above inbound policy with the tenant Id, client application id, and audience as per your environment. It is recommended to use APIM “Named values” instead of hard coding inside the policy. To learn more, visit Use named values in Azure API Management policies

Configure Diagnostics for APIM

In this solution, APIM diagnostics are configured to forward log data to Log Analytics. Testing and validation will be carried out using insights from Log Analytics.

Note: Setting up diagnostics is outside the scope of this article. However, you can visit the following link for more information. https://learn.microsoft.com/en-us/azure/api-management/api-management-howto-use-azure-monitor

 

 

Below diagram shows what Logs are being sent to Log Analytics workspace.

MCP Tool configuration in Copilot Studio

1. Lauch copilot studio at https://copilotstudio.microsoft.com/.


2. Configuration of environment and agent is beyond the scope of this article. It is assumed, you already have environment setup and agent has been created. Following link will help you, how to create an agent in copilot studio. Quickstart: Create and deploy an agent — Microsoft Copilot Studio | Microsoft Learn


3. Inside agent configuration, click “Add tool”.

 

3. Click on New tool.

 

4. Select Model Context Protocol.

5. Provide all relevant information for MCP server. Make sure your server URL ends with your mcp setup. In this case, it is APIM MCP server URL, with base path configured in APIM in the end. Provide server name and server description.

Select OAuth 2.0 radio button.

6. Provide the following in the OAuth 2.0 section

• Client ID of client app registration. In this case, copilot-studio-client as configured earlier.


• Client secret of copilot-studio-client app registration.


• Authorization URL: https://login.microsoftonline.com/common/oauth2/v2.0/authorize


• Token URL template & Refresh URL: https://login.microsoftonline.com/oauth2/v2.0/token


• Scopes: openid, profile, email — which we selected earlier for Microsoft Azure Graph permissions.


• Click “Create”.

This will provide you Redirect URL. you need to configure the redirect URL in client app registration. In this case, it is copilot-agent-client.

 

 

Configure Redirect URI in Client App Registration

Visit client app registration. i.e. copilot-studio-client. Click Authentication Tab and provide the Web Redirect URIs as shown below.

 

Note: Configure Redirect URIs MUST be configured in app registration. Otherwise, authorization will not complete and sign on will fail.

 

Configure redirect URI in APIM API app registration

Also configure apim-mcp-backend-api app registration with the same redirect URI as shown below.

Modify MCP connector in PowerApps

Now visit the https://make.powerapps.com and open the newly created connector as shown below.

Select the security tab and modify the Resource URL with application ID URI of apim-mcp-backend-api configured earlier in app registration for expose an API. Add .default in the scope. Provide the secret of client app registration as it will not let you update the connector. This is extra security measure for updating the connector in Powerapps.

Click Update connector.

 

CORS Configuration

CORS configuration is a MUST!!! Since our Azure Container App is a remote MCP server with totally different domain or origin.

Power Apps and CORS for External Domains — Brief Overview

When embedding or integrating Power Apps with external web applications or APIs, Cross-Origin Resource Sharing (CORS) becomes a critical consideration. CORS is a browser security feature that restricts web pages from making requests to a different domain than the one that served the page, unless explicitly allowed.

Key Points:

• Power Apps hosted on *.powerapps.com or within Microsoft 365 domains will block calls to external APIs unless those APIs include the proper CORS headers.


• The external API must return:


• Access-Control-Allow-Origin: https://apps.powerapps.com (or * for all origins, though not recommended for production)


• Access-Control-Allow-Methods: GET, POST, OPTIONS (or as needed)


• Access-Control-Allow-Headers: Content-Type, Authorization (and any custom headers)


• If the API requires authentication (e.g., OAuth 2.0), ensure preflight OPTIONS requests are handled correctly.


• For scenarios where you cannot modify the external API, consider using:


• Power Automate flows as a proxy


• Azure API Management or Azure Functions to inject CORS headers


• Always validate security implications before enabling wide-open CORS.

If the CORS are not setup. You will encounter following error in copilot studio after pressing F12 (Browser Developer)

 

 

CORS policy — blocking the container app

Azure container app provides very efficient way of configuring CORS in the Azure portal.

1. Lauch Azure Portal. Visit Azure container app i.e. streamable-mcp-server2 in this case.


2. Click on CORS under Networking section.


3. Configure the following in Allowed Origin Section as shown below. localhost is added to make it work from local laptop, although it is not required for Copilot Studio.

 

 

4. Click on “Allowed Method” tab and provide the following.

 

 

5. Provide wild card “*” in “Allowed Headers”tab. Although, it is not recommended for production system. it is done for the sake for simplicity. Configure that for added security

 

 

6. Click “Apply”. This will configure CORS for remote application.

Test the MCP custom connector

We are in the final stages of configuring the connector. It is time to test it, if everything is configured correctly and works.

1. Launch the http://make.powerapps.com and click on “Custom connectors”, select your configured connector and click “5. Test” tab as shown below. You will see Selected Connection as blank if you are running it first time. Click “+ New connection”

2. New connection will launch the Authorization flow and browser dialog will pop up for making a request for authorization code.

3. Click “Create”.

4. Complete the login process. This will create a successful connection.

5. Click “Test operation”. If the response is 406 means everything is configured correctly as shown below.

Solution validation

Add user in Enterprise Application for App roles

Roles have been defined under the required claims in the APIM inbound policy and also configured in the apim-mcp-backend-api app registration. As a result, any request from Copilot Studio will be denied if this role is not properly assigned. This role is included in the JWT access token, which we will validate in the following sections.

To assign role, perform the following steps.

1. Visit Azure Portal. Visit Enterprise Application.


2. Select APIM backend app registration. In this case for example, apim-mcp-backend-api


3. Click “Users and groups“


4. Select “Add user/group“
   
   

 

5. Select User or Group who should have access to the role.

6. Click “Assign“. It will look like as below.

 

Note: Role assignment for users or groups is an important step. If it is not configured, MCP server tests will fail in Copilot studio.

Test MCP server in Copilot Studio

1. Lauch copilot studio and click on the Agent you created in earlier steps and click on “Tools tab”. Select your MCP tool as shown the following figure.

Make sure it is “Enabled” if you have other tools attached to the same agent, disable them for now for testing.

Make sure you have connection available which we created during the testing of custom connector in earlier step. You can also initiate a fresh connection by clicking on the drop down under “Connection” as shown below.

Refreshing the tools will show all the tools available in this MCP server.

Provide the sample prompt such as “Give me the stock price of tesla”. This will trigger the MCP server and call the respective method to bring the stock price of Tesla.

Now try a weather-related question to see more.

Now invoking weather forecast tool in the MCP server.

APIM Monitoring with Log Analytics

We previously configured APIM diagnostic settings to forward log data to Log Analytics. In this section, we’ll review that data, as the inbound policy in APIM sends valuable information to Log Analytics.

Run the Kusto query to retrieve data from the last 30 minutes. As shown, the logs capture the APIM API endpoint URL and the backend URL, which corresponds to the Azure Container App endpoint.

Scrolling further, we find the TraceRecords section. This contains the information captured by APIM inbound policies and sent to Log Analytics. The figure below illustrates the TraceRecords data. In the inbound policy, we configured it to extract details from the access token—such as the token itself, username, scope, and roles—and forward them to Log Analytics.

Now let’s capture the access token in the clip board, launch the http://jwt.io which is JSON Web Token (JWT) debugger, and paste the access token in the ENCODED VALUE box as show below. Note the following information.

• aud: This shows the Application URI ID of apim-mcp-backend-api. which shows access token is requested for that audience.


• appid: This shows the client Id for copilot-studio-client app registration.


• You can also see roles and scope. These roles are specified in APIM inbound policy.

 

Note: As you can see, roles are included in access token and if it is not assigned in the enterprise application for “apim-mcp-backend-api”, all requests will be denied by APIM inbound policy configured earlier.

 

Perform a test using another Azure AD account that does not have the app role assigned

Now, let’s try the copilot studio agent by logging in with another account which is not assigned for the “mcp.read” role.

Let’s, review the below diagram.

 

• Logged in as demo and tried to access the MCP tool in copilot studio agent.


• Request failed with the error “Missing required scope or roles“. If you look at it, this is coming from the APIM policy configured earlier in  

 

Let’s review log analytics. As you can see request failed due to inbound APIM policy with 403 error and there is no backend URL. Error is also reported under TraceRecords as we configured it in APIM policy.

 

Now copy the Access token from log analytics and paste it into jwt.io. You can notice in the below diagram, there is no “roles” in the access token, resulting access denied from APIM inbound policy definition to the APIM backend i.e. azure container app.

Assign the app role to the demo account

Let’s assign the “mcp.read” role to the demo account and test if it accesses the tool.

1. Visit Azure Portal, Lauch Enterprise application, and select “apim-mcp-backend-api” as in this example.


2. Click “Users and groups“


3. Click “+ Add user/group“


4. Select demo 


5. Click “Select“


6. Click “Assign“

End result would look like as shown below.

Now, login again as demo.

Make sure a new access token is generated. Access token refresh happens after one hours.

 

As you can see in the image below, this time the request is successful after assigning the “mcp.read” app roles.

Now let’s review the log analytics entries.

Let’s review the access token in JWT.io. As you can see, roles are included in the access token.

 

Conclusion

Exposing the MCP server through Azure API Management (APIM) and integrating it with Copilot Studio agents provides a secure and scalable way to extend enterprise capabilities. By implementing OAuth 2.0, you ensure robust authentication and authorization, protecting sensitive data and maintaining compliance with industry standards.

Beyond security, APIM adds significant operational value. With APIM policies, you can monitor traffic, enforce rate limits, and apply fine-grained controls to manage access and performance effectively. This combination of security and governance empowers organizations to innovate confidently while maintaining control and visibility over API usage.

In today’s enterprise landscape, leveraging APIM with OAuth 2.0 for MCP integration is not just best practice—it’s a strategic move toward building resilient, secure, and well-governed solutions.