connector namespace
4 TopicsWhat's new in Azure Logic Apps at Microsoft Ignite 2026
Organizations are exploring how AI can make their business processes more intelligent, but many still rely on legacy integration infrastructure that makes innovation difficult. Bringing AI into enterprise operations requires more than connecting a model or deploying an agent. It requires reliable access to business systems and data, orchestration across applications and people, and the ability to act securely and predictably. Azure Logic Apps brings enterprise connectivity and orchestration together, helping organizations connect applications and data, automate processes across systems, and bring AI into business workflows with the reliability and control their operations require. At Microsoft Ignite 2026, we're advancing Azure Logic Apps across three priorities: modernize legacy integrations, build automation faster, and bring AI into business processes. Modernize the integrations your business depends on Legacy integration infrastructure continues to support critical business processes, but it can make adopting AI more complex. Organizations need to modernize without disrupting the systems they depend on. At Ignite, we're introducing new capabilities that help organizations modernize legacy integrations, connect more enterprise systems, and manage integrations across cloud and hybrid environments. Connect more enterprise systems: The HL7 connector is now generally available, while new MLLP and MSMQ connectors in public preview extend support for healthcare messaging and legacy applications. Data Mapper enhancements simplify transformations across applications and message formats, reducing custom integration work. Modernize across cloud and hybrid environments: Hybrid Logic Apps continues to expand with support for additional Kubernetes environments, including RKE2 and Red Hat OpenShift, alongside DevOps deployment capabilities and Integration Account support in semi-connected environments. Organizations gain greater flexibility to modernize integrations where their systems and data reside. Improve operational visibility: A new unified dashboard, available in public preview for individual Logic Apps, helps teams monitor workflow execution and troubleshoot integrations through a consolidated experience. These capabilities help organizations modernize at their own pace while maintaining the connectivity and reliability their businesses depend on. The Kentucky Cabinet for Health and Family Services (CHFS) shows what this can look like in practice. CHFS modernized its legacy on-premises BizTalk infrastructure to Azure Integration Services, including Azure Logic Apps, Azure API Management, and Azure Functions. The modernization improved scalability, reliability, and operational efficiency. Today, its integration environment processes approximately 7 million transactions daily, supports more than 1,800 APIs, and connects over 60 partners helping CHFS focus more on delivering essential public services and less on maintaining legacy infrastructure. Read the customer story here. Build automation faster Developers need the flexibility to build integrations and automations using familiar tools without maintaining custom integration infrastructure. At Ignite, we're expanding development options across managed connectivity and reusable automation experiences. Bring managed connectivity into application code: Azure Connector Namespace gives developers access to enterprise systems through .NET, Node.js, and Python SDKs or HTTP APIs without building and maintaining custom integration code. It also supports exposing connectors as MCP tools for AI agents. Explore Connector Namespace. Start faster and reuse proven patterns: Logic Apps Automation (preview) introduces a refreshed workflow designer and ready-to-use templates for integration, Azure operations, and AI-powered automation. Teams can also turn successful workflow runs into reusable templates and share them across projects and organizations. Together, these capabilities help teams reduce development overhead, accelerate delivery, and build integrations and automations using the tools and approaches that work best for them. Make business processes intelligent with AI As organizations introduce AI into business processes, they need to combine predictable workflows with AI-powered decisions, agent reasoning, and human involvement. At Ignite, we're expanding Logic Apps Automation (preview) to help organizations bring these capabilities together while maintaining enterprise reliability and control. Orchestrate workflows and agents: Logic Apps Automation brings workflows, enterprise systems, agents, and people together within business processes. Through integration with Microsoft Foundry, organizations can bring agents built in Foundry into workflows orchestrated by Logic Apps, connecting AI-powered reasoning and actions to enterprise systems and human approvals. Apply AI where an agent isn't required: Decision actions, now in public preview, use Microsoft-Decision-1 to perform focused judgments such as classifying requests, routing tickets, and assessing urgency. Yes/No, Choice, and Score actions return structured results that workflows can act on directly. Bring AI into workflows without managing models: Managed AI Models in Logic Apps Automation (preview) provide ready-to-use AI capabilities without requiring developers to provision or manage model infrastructure. Together, these capabilities help organizations apply the right intelligence to each business process using workflows for predictable tasks, AI for focused decisions, and agents for more complex reasoning and action. Enterprise-ready automation, built for scale As automation expands across business systems, organizations need secure connectivity and reliable operations. At Ignite, we're enhancing Logic Apps Automation with built-in connectors for GitHub, Azure DevOps, Azure Monitor Logs, Azure Resource Graph, and Azure Advisor, along with virtual network integration for access to private enterprise resources. Learn more about these new capabilities in Logic Apps Automation. Building the future of intelligent enterprise automation The next generation of enterprise automation will bring workflows, AI agents, enterprise systems, and people together connecting applications and data while coordinating how work gets done. With the innovations announced at Microsoft Ignite 2026, Azure Logic Apps is helping organizations move from traditional integration and automation toward more intelligent business processes, built on the connectivity, reliability, and control enterprises depend on. Join us at Microsoft Ignite 2026 If you're attending Microsoft Ignite in San Francisco, join us to explore the latest Azure Logic Apps innovations, see demos, and connect with our product experts. Modernize legacy integration with Azure Logic Apps Reimagine agentic business processes with Logic Apps Automation How are you reimagining business processes with Logic Apps Automation? Give your agent a thousand tools: Connectors as MCP for AI Your agent wrote the workflow. Who watches it run? Stop by the Serverless Apps and Agents booth to meet our product team, see the latest capabilities in action, ask questions, and share what you're building. We look forward to seeing you there!Run MCP tools as the signed-in user: on-behalf-of authentication in Connector Namespace
What is on-behalf-of authentication OBO is a standard Microsoft Entra ID OAuth 2.0 flow. A service receives a user's token, exchanges it for a new token for a downstream API, and that new token still represents the same user. In Connector Namespace, you turn it on per MCP connector (a set of connector operations exposed as Model Context Protocol tools) by setting its authentication mode to OnBehalfOfUser. In the portal, this option is called Per-user authentication. From then on: There's no shared connection. The first time a user calls a tool, the namespace creates a connection for that user and that MCP connector. The user signs in to the connector once. Later calls reuse their connection. Connector credentials stay in the namespace. Your app never sees them. Developer connection (default) On-behalf-of user Runs as The connection owner The user calling the tool Connections One, shared by every caller One per user, created on first use What the agent can reach Everything the owner can reach Only what that user can reach Why it matters An agent that reads files or tickets for an employee should see only what that employee can see. With OBO, it does, because every call runs with the user's own permissions in the downstream system. OBO uses delegated permissions, so it never gives a user access they don't already have. That changes three things for you: No shared service account. Nothing in your namespace holds broad access on behalf of everyone. Actions belong to real people. The downstream system sees the user, not a service account, so its audit trail stays meaningful. Access is yours to pull. Remove an app or user from the MCP connector's access policies and their calls stop. Targets: where OBO applies OBO targets connector-backed MCP connectors that use Per-user authentication (OnBehalfOfUser in the API and CLI). It works with any managed connector that supports OAuth sign-in, such as SharePoint Online and Office 365 Outlook. Connectors that don't support OAuth can't use this mode. Two details shape your design: Each OBO MCP connector wraps exactly one connector. Need SharePoint and Outlook? Create two MCP connectors. Every call needs two matches: an Application access policy for the calling app, and a User or Group policy for the signed-in user. Permissions on a connection don't count toward this check. Hosted MCP servers have their own OBO mode with an admin app registration. That's a separate post. Prerequisites You need four things before the walkthrough. The first two are one-time tenant setup, usually done by an Entra admin. A connector namespace. Plus Owner or Contributor on it. See Create a connector namespace. The Azure API Connections enterprise application in your tenant. This is a Microsoft first-party app, not an Azure resource you deploy. It represents the namespace runtime in Entra ID (application ID fe053c5f-3692-4f14-aef2-ee34fc081cae, audience https://apihub.azure.com). Check whether your tenant already has it: az login --tenant "<tenant-id>" az ad sp show --id fe053c5f-3692-4f14-aef2-ee34fc081cae If it's missing, an Entra Application Administrator or Cloud Application Administrator creates it: az ad sp create --id fe053c5f-3692-4f14-aef2-ee34fc081cae These identifiers are for Azure public cloud. Verify the app ID and audience before you use another cloud. An app registration for your agent or app. This is the caller. It must be a confidential client (secret, certificate, or federated credential) in the same tenant as your users. Public clients and app-only tokens don't qualify. In its API permissions: Select Add a permission, then APIs my organization uses, and search for Azure API Connections (or the application ID above). Select Delegated permissions, then Runtime.All (scope ID 6c3012bf-22c1-4bb5-959b-dff738314144). Select Grant admin consent for your tenant. You will also need The users or groups who'll use the agent. You need their object IDs from the Microsoft Entra admin center. Walkthrough: an agent that only sees your files The scenario: an HR policy agent that searches SharePoint document libraries. Two employees ask the same question. Each gets answers only from files they can open. Step 1: Create the MCP connector Open your namespace in the portal at connectors.azure.com and select MCP Connectors. Create a new MCP connector, pick the SharePoint Online connector and select an existing connector or create a new one Under authentication, select Per-user authentication. Under tools select the tools you want to expose. Get file content Get file metadata Get file properties List folder List root folder The portal uses your own sign-in to read the connector's operations while it builds the tools. At runtime, each user gets their own connection. Pick the mode carefully. It's fixed once set. To switch modes, you recreate the MCP connector. Step 2: Add access policies In the MCP connector, select Access Policies, then + Add Access Policy, and add two policies: Application, with your app registration's client ID and tenant ID. User or Group, with the object ID and tenant ID. Watch the IDs. Applications use the client (application) ID, users and groups use the object ID, and swapping them gets the policy rejected. Step 3: Get a delegated token in your app Your agent backend already receives a user token for its own API. Exchange it with MSAL's on-behalf-of flow for the Runtime.All scope: var app = ConfidentialClientApplicationBuilder .Create(clientId) .WithClientSecret(clientSecret) // or a certificate or federated credential .WithAuthority($"https://login.microsoftonline.com/{tenantId}") .Build(); var result = await app .AcquireTokenOnBehalfOf( new[] { "https://apihub.azure.com/Runtime.All" }, new UserAssertion(incomingUserToken)) .ExecuteAsync(); If your app signs the user in directly, request the same scope during sign-in instead. Either way, the token should have audience https://apihub.azure.com and scope Runtime.All. Step 4: Call the MCP endpoint Copy the MCP endpoint URL from the MCP connector's overview. Don't build it from the resource name. Send the token as a bearer token: POST <mcp-endpoint-url> Authorization: Bearer <delegated-token> Content-Type: application/json {"jsonrpc":"2.0","id":"1","method":"tools/list","params":{}} Step 5: Handle first-time consent The first time a user calls a tool, they haven't connected to SharePoint yet. The response is HTTP 200 with a JSON-RPC error: {"jsonrpc":"2.0","id":"<request-id>","error":{"code":-32001,"message":"<consent-required-message>","data":{"url":"<consent-url>","connectorName":"sharepointonline","connectionId":"<connection-id>"}}} Show the user a sign-in action that opens error.data.url , then retry the call. Don't treat HTTP 200 as success on its own. If your MCP client supports URL elicitation, turn on consent elicitation in the MCP connector settings and you'll get an elicitation/create request instead. Before you build: what to know One connector per MCP connector. Group tools by connector. Same-tenant users only. Guest and cross-tenant users aren't supported yet. Consent is per user, per connector. Design your client for the consent response from day one. Feedback I want to know where this breaks for you. Point it at the connector your agent depends on most, run it as two different users, and tell me what you see. File issues and requests at GitHub Issues. That list decides what we build next. Portal: connectors.azure.com GA announcement: aka.ms/connector-namespace/ga/blogPolling triggers in Connector Namespace: let your code pull connector events
What is a polling trigger? A trigger configuration in Connector Namespace ties an event in an external service, such as a new row in a SQL table, a new email or a new file, to a destination. Each trigger configuration has a delivery mode that decides how events get from the namespace to your code. With webhook delivery, the namespace pushes each event to a callback endpoint on your app. With polling delivery, the namespace holds the events for the trigger configuration, and your code connects outbound to retrieve them, processes them, and acknowledges each one when it's done. In Azure Functions you don't even write that loop: the Connector extension runs it and hands your function the events. On the namespace side, a polling trigger configuration gets its own event queue, handles large messages, keeps run history, and protects against duplicate delivery. One distinction is worth calling out early. The delivery mode controls how events travel from the namespace to your function app. It doesn't change how the managed connector detects changes in the source system. In the walkthrough below, the SQL connector still checks the table for new rows; polling only changes the last hop. While polling is only supported out of the box in Azure Functions today, support for polling will be implemented for other partner services based on customer feedback. So, make your voice heard if it is something you want to see on other applications. Why it matters Choosing a delivery mode comes down to four things: latency, processing capacity, networking and authentication. Webhook delivery still wins on latency. Polling is the better fit for the other three. Capability Polling Webhook Event delivery and latency The Functions host retrieves events through outbound requests. Events wait until the host polls. The namespace pushes events as soon as it picks them up from the source. Lower latency. Processing capacity The host takes more events as capacity frees up. Pending events stay queued in the namespace, subject to its retention limits. Events arrive regardless of the app's capacity. Throttled or failed callbacks can lose events once retries run out. Inbound networking No inbound endpoint. Only outbound HTTPS to the namespace polling endpoint. The namespace must be able to reach the app's callback endpoint. Authentication The function app's managed identity, with an access policy on the connection. The Connector extension system key by default, or Microsoft Entra ID with App Service built-in authentication. Your function sets the pace With webhook delivery, events land whenever the source produces them. If your app is at its scale-out limit, callbacks get throttled or fail, and an event that isn't delivered within the service's retry limits can be lost. With polling, the backlog waits in the namespace and the host pulls more work only when it has capacity. Combine your app's scale-out limit with the polling concurrency settings and you have a hard ceiling on how hard your function hits the database or API behind it. No public endpoint Polling doesn't need a public callback URL or a function app system key, because your app retrieves events instead of receiving callbacks. You can put the function app behind private endpoints or inbound access restrictions, and polling keeps working as long as the app can make outbound HTTPS calls to the namespace. Managed identity instead of keys The Functions host authenticates with Microsoft Entra ID. In Azure, that's the function app's system-assigned or user-assigned managed identity. On your machine, it's your developer identity. Either way, access is granted with an access policy on the managed connector connection, so there's no secret to store or rotate. Scale that follows the backlog In polling mode, the Connector trigger uses target-based scaling based on the estimated event backlog for the trigger configuration. The scaling target is independent of batch size and per-instance concurrency, so you can tune throughput and protection separately. What you trade Latency. An event waits in the namespace until the host polls for it. You can shorten the gap with the maxPollingInterval host setting, but if every millisecond counts, webhook is still the right mode. Polling delivery is also at least once: a failed invocation isn't acknowledged, and the event can come back after its lock expires, so make your processing idempotent. Polling at a glance Before the Azure Functions walkthrough, here's the shape of any polling setup. The first two steps happen in Connector Namespace and don't depend on the compute you choose. The last two happen wherever your code runs. Create a polling trigger configuration in your connector namespace. Pick the connector, the event, the connection and the inputs, and set the delivery mode to Polling. From then on, the namespace holds events for that configuration until your code takes them. Grant the consuming identity access with an access policy on the managed connector connection. In Azure that's a managed identity; on your machine it's your developer identity. No keys or secrets change hands. Point your code at the namespace with the polling endpoint and the trigger configuration name. There's no callback URL to register, so the consumer can sit behind private endpoints or inbound access restrictions. Poll, process and acknowledge. Your code retrieves events when it has capacity, processes them and acknowledges each one. An event that isn't acknowledged becomes available again after its lock expires, which is why delivery is at least once. In Azure Functions, the Connector extension takes care of the fourth step: you declare the trigger, and the host runs the polling loop, invokes your function and acknowledges the events. The walkthrough maps onto the same pattern. You create the trigger configuration in Step 2, wire up the polling endpoint in Steps 3 and 6, and grant access in Steps 4 and 7. livery pushes events into your app; polling delivery lets your app pull them. Walkthrough: process new SQL orders with a polling trigger Here's the scenario. You have an Orders table in Azure SQL Database. SQL doesn't call anyone when a row is inserted, and the fulfilment system downstream can only take so many requests at once. You want a function that picks up each new order, without opening an inbound endpoint and without flooding fulfilment when a batch of orders lands at once. Figure: the walkthrough scenario. The numbers match the four steps in Polling at a glance. The walkthrough uses C# with the .NET isolated worker and the Connector Namespace portal. Python and Node.js follow the same steps; the documentation has the code for both. Before you start You need: An Azure subscription and a connector namespace. If you don't have one, create a connector namespace first. An Azure SQL database with an Orders table. The SQL connector's new-item trigger needs an IDENTITY column on the table. A .NET isolated worker Functions project, Azure Functions Core Tools and the Azure CLI. Step 1: Add the Connector extension Add version 1.0.0 or later of the Connector extension package to your project: dotnet add package Microsoft.Azure.Functions.Worker.Extensions.Connector Step 2: Create the polling trigger configuration Go to the Connector Namespace portal and select your namespace. In the namespace menu, select Triggers, and then select Create. Find the SQL Server connector and select the When an item is created (V2) event. Create a connection or select an existing one. Creating a connection takes a one-time authentication with your SQL server. Provide the inputs the event needs: the server, the database and the Orders table. For Destination type, choose Azure Functions. For message delivery method, choose Polling. Review the configuration, and then select Create. Unlike webhook delivery, you don't need the function app deployed before you create the trigger configuration. The function finds the configuration by name. Step 3: Copy the polling endpoint Your function needs the namespace's polling endpoint. Copy it from the trigger configuration in the Connector Namespace portal: Configuration Required Portal Value ConnectorNamespace__PollingEndpoint Base Url configuration %TriggerConfigurationName% Trigger Configuration name Step 4: Grant access to the connection The identity that polls needs an access policy on the managed connector connection. Note that the policy goes on the connection, not on the namespace, and that signing in or turning on a managed identity doesn't grant this access by itself. For local development, the caller is your developer account. For a deployed app, it's the app's managed identity. Use the principal (object) ID, not the application (client) ID. In the Connector Namespace portal, select your namespace and open Connections. Select the SQL Server connection your trigger configuration uses. Open the Access Policies tab and add a policy for the caller identity. Check that the caller now appears in the connection's access policies. Step 5: Write the function The SQL connector doesn't have a strongly typed .NET payload yet, so the function binds to string and receives the raw JSON. Connectors that do have typed payloads, such as Office 365 Outlook, can bind to their payload model instead. using System.Text.Json; using Microsoft.Azure.Functions.Worker; using Microsoft.Azure.Functions.Worker.Extensions.Connector; using Microsoft.Extensions.Logging; namespace Contoso.Products; public class SQLServerOnNewProduct { private readonly ILogger<SQLServerOnNewProduct> _logger; public SQLServerOnNewProduct(ILogger<SQLServerOnNewProduct> logger) { _logger = logger; } [Function(nameof(SQLServerOnNewProduct))] public void Run( [ConnectorTrigger( DeliveryMode = ConnectorTriggerDeliveryMode.Poll, Connection = "ConnectorNamespace", TriggerConfigName = "%ONSQLNewProductTriggerConfigName%")] string payload) { using var document = JsonDocument.Parse(payload); var productName = document.RootElement .GetProperty("body") .GetProperty("Name") .GetString() ?? throw new JsonException("The product name must not be null."); _logger.LogInformation("Received product: {ProductName}.", productName); } } Three properties do the work. DeliveryMode = ConnectorTriggerDeliveryMode.Poll switches the trigger from the default webhook mode to polling. Connection = "ConnectorNamespace" is a settings prefix: the extension reads the polling endpoint from ConnectorNamespace__pollingEndpoint and the identity settings from the same prefix. TriggerConfigName points at the trigger configuration, here through the NewOrderTriggerConfigName app setting so you can change it per environment. Step 6: Run it locally Add the settings to the Values section of local.settings.json : { "IsEncrypted": false, "Values": { "AzureWebJobsStorage": "UseDevelopmentStorage=true", "FUNCTIONS_WORKER_RUNTIME": "dotnet-isolated", "ConnectorNamespace__pollingEndpoint": "<my-trigger-base-url>", "ONSQLNewProductTriggerConfigName": "<my-trigger-configuration-name>" } } Leave out ConnectorNamespace__credential locally, and the extension uses your developer credentials. Sign in, start the host, and insert a row: az login func start -- Insert 3 sample products into AdventureWorksLT (SalesLT.Product) -- ProductID is an IDENTITY column; rowguid and ModifiedDate have defaults. INSERT INTO SalesLT.Product (Name, ProductNumber, Color, StandardCost, ListPrice, Size, Weight, ProductCategoryID, SellStartDate) OUTPUT inserted.ProductID, inserted.Name, inserted.ProductNumber, inserted.ListPrice, inserted.ModifiedDate VALUES (N'Polling Trail Bike 42', N'CN-POLL-001', N'Red', 812.50, 1299.99, N'42', 11800.00, (SELECT ProductCategoryID FROM SalesLT.ProductCategory WHERE Name = N'Mountain Bikes'), GETDATE()), (N'Polling Aero Helmet', N'CN-POLL-002', N'Black', 22.75, 49.99, NULL, NULL, (SELECT ProductCategoryID FROM SalesLT.ProductCategory WHERE Name = N'Helmets'), GETDATE()), (N'Polling Water Bottle 750ml', N'CN-POLL-003', N'Blue', 2.10, 6.99, NULL, NULL, (SELECT ProductCategoryID FROM SalesLT.ProductCategory WHERE Name = N'Bottles and Cages'), GETDATE()); Within the next polling cycle, the function logs the new order. Step 7: Deploy with a managed identity In the Azure portal, open your function app, go to Identity, and turn on the system-assigned managed identity. You can assign a user-assigned identity instead. Grant that identity an access policy on the SQL Server connection, as in step 4, using its principal (object) ID. Add the app settings below under Environment variables. Publish the app with func azure functionapp publish <FUNCTION_APP> . App setting Value ConnectorNamespace__pollingEndpoint The polling endpoint from step 3 NewOrderTriggerConfigName new-orders ConnectorNamespace__credential managedidentity ConnectorNamespace__clientId The client ID of the user-assigned identity. Set it only for a user-assigned identity, or set ConnectorNamespace__managedIdentityResourceId instead. Omit both for a system-assigned identity. Because nothing calls into the app, you can now restrict inbound access with private endpoints or access restrictions. Polling only needs outbound HTTPS to the namespace. Step 8: Tune throughput and protect what's downstream The defaults work, but polling gives you levers that webhook doesn't. To take orders in batches, turn on batching and bind to an array of events: [Function("OnNewOrders")] public void OnNewOrders( [ConnectorTrigger( DeliveryMode = ConnectorTriggerDeliveryMode.Poll, Connection = "ConnectorNamespace", TriggerConfigName = "%NewOrderTriggerConfigName%", IsBatched = true, MaxBatchSize = 8, TargetPendingEventThreshold = 16)] ConnectorEvent<string>[] events) { foreach (var orderEvent in events) { logger.LogInformation("Processing event {MessageId}.", orderEvent.MessageId); // Parse orderEvent.Data and hand the order to fulfilment. } } Property Default What it controls IsBatched false Whether each invocation receives a batch of events. Batches are processed one at a time per listener. MaxBatchSize 1 Maximum events per invocation, from 1 through 32. Must be 1 when IsBatched is false. MaxConcurrentCalls 16 Maximum concurrent single-event invocations per listener on one instance. Applies only when IsBatched is false. TargetPendingEventThreshold 16 Desired pending events per instance for target-based scaling. Doesn't change batch size or concurrency. Each property falls back to an app-wide default in host.json when you omit it or set it to 0. The same section holds the polling interval. This example caps the wait between polls at one second when no events are available: { "version": "2.0", "extensions": { "connector": { "maxPollingInterval": "00:00:01" } } } Two more things before you go to production. Delivery is at least once, so make the processing idempotent; for an order, that usually means checking whether you've already sent it to fulfilment. If you deduplicate on ConnectorEvent<T>.MessageId , scope it to the namespace and trigger configuration, because message IDs aren't guaranteed unique across triggers. Feedback Polling is the first delivery mode in Connector Namespace where your code sets the pace, and we want to know how it holds up in your workloads. I'm especially interested in three things: which source systems you're polling, how you're setting batch size and concurrency, and what's missing before you'd run it in production. Tell us in GitHub Issues. For bugs in the Connector extension, open an issue here. To go further: Connector trigger for Azure Functions Connector extension for Azure Functions overview Use managed connectors in Azure Functions Connector Namespace portal Connector Namespace GA announcementBring your own APIs and MCP servers: custom connectors in Connector Namespace
What is a custom connector A custom connector describes an API or MCP server that isn't in the managed catalog, so your namespace can call it like any other connector. You register it once in the namespace, next to the 1,400+ managed connectors, then build connections and MCP connectors from it. There are two kinds: OpenAPI custom connector MCP server custom connector You provide An OpenAPI definition of your REST API The URL of a remote MCP server Tools come from The namespace, generated from the operations you expose Your MCP server, passed through as-is Typical use Internal APIs that don't speak MCP Your own or a partner's MCP server Both kinds use the same building blocks as managed connectors. A connection holds the backend credential. An MCP connector publishes the MCP endpoint your agents call. Why it matters Agents rarely work only with catalog systems. The order API, the pricing service, the partner's inventory server: that's where the work happens. Without custom connectors, each one needs its own credential store, its own caller checks, and its own MCP plumbing. With custom connectors, your systems get the same treatment as Salesforce or ServiceNow: Secrets stay in the namespace. The backend API key or OAuth token lives in the connection. Your agent never sees it. One access model. Callers present a Microsoft Entra ID token, and access policies on the MCP connector decide who gets in. One endpoint shape. Your agent calls your API, your partner's server, and every catalog connector through MCP endpoints from the same namespace. Targets: MCP custom connectors This post covers MCP connectors built on custom connectors, using a shared connection: everyone you admit uses the same backend credential, so scope it to what the agent needs. The two kinds behave differently once they're behind an MCP connector: OpenAPI custom connector: generated tools. The namespace turns each operation you expose into a tool, so clear operation IDs and summaries in your definition make better tools. MCP server custom connector: passthrough. The namespace forwards initialize , tools/list , and tools/call to your server. Your server owns its tool names, schemas, and results. The namespace decides who can call it and which credential it sends. Two related topics are covered elsewhere. Hosted MCP servers, where the namespace runs the server for you, are in Hosted MCP servers in Connector Namespace. Per-user authentication works with custom connectors that use OAuth, and the OBO deep dive explains it. Prerequisites A connector namespace, plus Owner or Contributor on it. See Create a connector namespace. For an OpenAPI custom connector: an OpenAPI 2 or 3 definition of your API, and an HTTPS endpoint the namespace can reach. For an MCP server custom connector: a remote MCP server that accepts streamable HTTP over HTTPS. The namespace calls it with HTTP POST. It doesn't run local stdio servers. The backend credential for each system, such as an API key. The object IDs of the users, groups, or apps that will call the MCP connectors. Walkthrough: Contoso orders Contoso's customer service agent answers "where's my order?" questions. It needs two systems that aren't in the catalog: Contoso Orders API, an internal REST API with an OpenAPI definition, protected by an API key. Fabrikam inventory, an MCP server run by Contoso's logistics partner, also protected by an API key. You'll build one MCP connector for each, then point the agent at both endpoints. Creating tools from your REST API Step 1: Create the custom connector Open your namespace at connectors.azure.com, select Custom connectors, then + Create. Name it ContosoOrders and choose OpenAPI. Upload the Orders API definition. Under authentication, choose API key and set the header the API expects, such as X-Contoso-Key . You don't enter the key here. It goes in the connection. Step 2: Create the connection Select Connections, then + Create, and pick ContosoOrders . Paste the Orders API key and save. The key now lives in the namespace. Step 3: Create the MCP connector Select MCP Connectors, then + Create. Under Choose a connector, pick ContosoOrders , then select the connection you just made on the Authentication step. Name it OrdersMCP . On the Tools step, select the operations to expose as tools, such as GetOrder and ListOrdersByCustomer . Leave out anything the agent shouldn't call, such as CancelOrder . Step 4: Test in the playground On the MCP connector's Settings tab, turn on API key under Authentication, then select Playground. Run Initialize and List tools, then call GetOrder with a real order number. When you're done testing, turn API key authentication off again: API keys skip access policies. Path B: your MCP server, through the namespace Step 1: Connect the endpoint Select MCP Connectors, then + Create. Under Connect an MCP server, find Connect an existing MCP endpoint and select Configure endpoint. Enter the server URL, for example https://mcp.fabrikam.example/mcp , and name the MCP connector FabrikamInventoryMCP . On the Authentication step, choose API key, set the header Fabrikam expects, and enter the key Fabrikam gave you. You don't describe each tool. Behind the scenes, the wizard registers Fabrikam's server as an MCP server custom connector (fabrikam-inventory in Figure 1) with one forwarding operation, and Fabrikam's server lists its own tools. Step 2: Review the tools Finish the Tools step and create the MCP connector. There's nothing to pick: the agent gets every tool Fabrikam's server lists, so limit tools on the server side. Step 3: Test in the playground Open the playground as in path A and run List tools. You see Fabrikam's tools, such as check_stock , not anything the namespace generated. Feedback Tell me which API or MCP server you bring in first, and where it fights you. Run both paths against a system you own, then file issues and requests at GitHub Issues. I read every one, and they shape what we build next. Learn more Portal: connectors.azure.com Documentation, including limits and protocol details: [Link to custom connector documentation] GA announcement: aka.ms/connector-namespace/ga/blog OBO deep dive: aka.ms/connector-namespace/obo/blog