Preview. Azure Connector Namespace is in preview and subject to the Supplemental Terms of Use for Microsoft Azure Previews. During preview it's available in Azure public regions only, with no SLA.
The integration tax nobody budgets for
It is always a simple task on paper: connect apps to the systems the business actually runs on — SharePoint, Salesforce, SAP, Outlook — and get back to building features. What gets in the way is rarely the business logic. It's the plumbing. You write a custom API client for each service. You wire up OAuth flows and then babysit token refresh. You add retry policies, handle throttling, page through results, and stand up webhook subscriptions you now have to keep alive. None of that is the feature. All of it is on you.
Historically, if you wanted that work done for you, the answer was a workflow engine. That's great when you want a workflow — but a lot of apps just want to call an action or react to an event from code they already have, running on the compute they already use. That's the gap Azure Connector Namespace fills.
What is Azure Connector Namespace?
Azure Connector Namespace is a fully managed integration service that hosts a catalog of prebuilt, reusable connectors and MCP servers that your apps consume through a consistent programming model. Instead of writing and operating a client for each system, you create a connection once and call typed operations from your code. The namespace handles authentication, credential rotation, polling, webhook delivery, retries, throttling, and error handling on your behalf.
Worth saying clearly, because people ask: a connector namespace is independent of Azure Logic Apps. It doesn't require, use, or change anything in Logic Apps, and the Logic Apps connectors gallery keeps working separately for workflows. Connector Namespace is the integration path for compute that doesn't run on a workflow engine — your Functions, Container Apps, App Service, and self-hosted services.
Each connector exposes three kinds of surface through one shared connection model:
- Triggers — event subscriptions your app registers (a new email arrives, a record updates, a file lands in a folder).
- Actions — operations your app calls (send a message, read a row, upload a file).
- AI agent tools — the same operations, exposed to agents and Copilot through MCP servers.
You call all of it from strongly typed SDKs for C# (Azure.Connectors.Sdk), Node.js (@azure/connectors), and Python (azure-connectors) — or over plain HTTP if a typed SDK isn't a fit.
The building blocks
Five concepts and you have the whole model:
|
Concept |
What it is |
|
Connector namespace |
The Azure resource that hosts the connector runtime — loads and runs operations, maintains connection state and credentials, polls source systems, dispatches webhook events, and applies retry and diagnostic policies. Create it from the Azure portal, ARM/Bicep, or the CLI. |
|
Connector |
A prebuilt component for one service (SharePoint, Salesforce, SAP, Outlook). It abstracts the underlying API, auth protocol, pagination, and retry behavior so your code stays on business logic. |
|
Connection |
An authenticated, configured binding to an account or tenant. Connections are reusable — multiple apps and connectors can share one. Auth types: OAuth, API key, and Basic. |
|
MCP server |
A first-class resource that exposes tools to AI agents over the Model Context Protocol. Comes in managed and hosted flavors (more below). |
|
Connector SDKs |
Strongly typed clients for C#, Node.js, and Python that share the same catalog, connection model, telemetry, and retry semantics. Or call connectors over HTTP. |
What you can actually do with it
The point of all this is the scenarios it unlocks. A few that show the range:
|
Scenario |
What it looks like |
|
Process documents and content |
An Azure Function uses SharePoint connector operations to detect new or updated files, processes them, and writes results back to SharePoint. |
|
Monitor events from external services |
An Azure Container App uses a Salesforce trigger to receive events about new leads as they're created. |
|
Automate productivity |
A Node.js app uses Outlook operations to read and send email — reusing a connection another app already owns. |
|
Ground AI and agentic workloads |
A Python service calls connector actions to enrich model output with data from business systems. |
|
Reuse existing app code |
ASP.NET, Node.js, and Python services use managed integrations with no workflow engine in the call path. |
|
Publish connectors to agents |
Turn any connector into an MCP server in one step so Copilot and other agents can call it as a tool. |
Connections: authenticate once, reuse everywhere
Connections are where the Logic Apps connector ecosystem pays off. You get the same broad catalog of first-party Azure services and popular SaaS apps — built on years of connector investment — without bringing a workflow engine along for the ride. You create a connection to a service, authenticate it once, and then any number of apps and connectors reuse it.
Creating one is deliberately simple, which is the point:
- In the Connector Namespaces portal (connectors.azure.com), open your namespace and select Connections > Create connection.
- Find and select the connector — say, Office 365 Outlook.
- Give the connection a clear, specific name so it's easy to pick later.
- Sign in to authorize, and complete any extra steps the service requires.
- Confirm the connection shows as healthy on the Overview page — it's now ready for your apps to use.
Supported authentication types today are OAuth, API key, and Basic. And because the namespace stores and rotates the credentials, your app never touches a raw secret.
Triggers: deliver events to the compute you already run
A trigger is an event subscription your app registers on a connector — new email, updated record, new file. When the source system raises that event, the namespace delivers the payload to your compute. And it does the hard part for you: it manages polling schedules and webhook registration based on what the underlying service supports, so you don't stand up or maintain subscription infrastructure.
Your app can receive those events running on:
- Azure Container Apps Sandboxes
- Azure Functions
- Direct HTTP — App Services or self-hosted ASP.NET, Node.js, or Python on AKS or VMs, through the same connector namespace.
Two details that matter in practice: a trigger is defined independently of any specific app, and multiple apps can subscribe to the same trigger event over the same connection. Actions, for contrast, run synchronously when your app calls them; trigger delivery uses webhooks or pull-based subscriptions depending on the connector and source service.
You can learn more about how to use the Connectors SDK to inject connectors on Azure Functions here.
MCP servers: turn connectors into agent tools
This is the part I'm most excited about. An MCP server in your namespace exposes tools that AI agents — Copilot, custom agents, any MCP-aware client — can discover and call, using the same connection model as everything else. That's how you put your line-of-business systems directly in front of an agent without writing tool wrappers or standing up hosting. There are two ways to get one.
Managed MCP servers
Take any connector in your namespace and publish it as an MCP server in a single step. The namespace builds and configures the server — tool definitions, lifecycle, runtime — and the only thing you do is authenticate the underlying connection. If you can create a connection, you can give an agent a tool.
Hosted MCP servers
Sometimes you want a ready-made server rather than one projected from a connector. Hosted MCP servers are pre-built images from a curated catalog that the namespace runs in dedicated compute it provisions for you. You own the configuration; the platform handles hosting, scaling, networking, lifecycle, dependencies, health monitoring, and credentials. When you deploy one, the namespace pulls the image, provisions the runtime with your config, and exposes a secure MCP endpoint agents can connect to.
The curated catalog during preview includes:
- Playwright — browser automation tools for navigation, screenshots, and page interaction.
- Azure SQL — SQL operations exposed as MCP tools through Data API builder, with entity abstraction, RBAC, and caching so agents work through a controlled, secure contract.
It's a deliberately curated set today, and it expands over time based on demand. You can learn more about Hosted MCP Servers here.
How agents authenticate
Hosted MCP servers have two auth boundaries:
- Inbound (client to server) — OAuth with Microsoft Entra ID. Connections from GitHub Copilot in VS Code work out of the box; other MCP clients need a little extra config.
- Outbound (server to downstream system) — either a managed identity assigned to the namespace, or on-behalf-of (OBO) using the calling user's identity for delegated access.
How it fits together
End to end, the flow for connectors is short:
- Create a connector namespace resource in your subscription.
- Create one or more connections to the services you want — say, an OAuth connection to Microsoft 365.
- Your app — in Functions, Container Apps, App Service, or self-hosted compute — references the namespace and connection through a Connector SDK, then subscribes to triggers or calls actions.
- The namespace handles authentication, request signing, polling, webhook subscription, and retries. Your app gets back typed responses and event payloads.
For MCP servers, it's the same shape: create the namespace, add a managed or hosted server from the catalog, authenticate the underlying connection, and agents can find the server, read its tool catalog, and invoke tools.
Where you can run it
- Azure compute — App Service, Container Apps, and Functions can all consume connector operations.
- Self-hosted — any self-hosted service works too: ASP.NET, Node.js, or Python on AKS or Azure VMs.
- Agents, directly — Copilot extensions and MCP-aware clients call tools on MCP servers in your namespace without going through a separate compute layer; the namespace provides the compute that runs the servers.
Security and governance, by default
- Credentials stay with the namespace — it stores, manages, and rotates them; your app never handles raw secrets.
- Network isolation — restrict access with virtual network integration and private endpoints.
- RBAC — control who can create connections, register triggers, and invoke actions.
- Observability — diagnostic logs and correlation IDs flow to Azure Monitor for end-to-end tracing across the namespace and your compute.
Before you build: preview realities
I'd rather you go in clear-eyed. While Connector Namespace is in preview, keep these in mind:
|
Consideration |
What to expect |
|
No SLA |
Not recommended for production workloads during preview. |
|
Region availability |
Limited regions today; the list expands over time. |
|
Connector coverage |
High-usage and standard connectors first; enterprise connectors like SAP, IBM MQ, and Oracle Database follow in later waves. |
|
Identity |
API key and OAuth connections now; managed identity for connections comes later (and arrives earlier for select MCP servers). |
|
Versioning |
SDK and namespace runtime versions are paired during preview — expect breaking changes between milestones. |
|
Pricing |
The pricing model isn't finalized; the metering shape may change before GA. |
Try it, and tell us your feedback
If you've ever shipped an integration and then spent the next quarter maintaining its plumbing, this is for you. The preview is open: create a namespace from the Azure portal, wire up a connection at connectors.azure.com, and call your first action or publish your first MCP server. It is easy to start here:
Learn more:
- What is Azure Connector Namespace?
- Quickstart: Create and manage connector namespaces
- Create reusable connections in connector namespaces
- Hosted MCP servers in Azure Connector Namespace
Related Blog Posts:
Samples repositories:
This is a preview, which means your feedback genuinely shapes where it goes — which connectors come next, which MCP servers land in the catalog, where the rough edges are. Bring issues, feature requests and feedback to our GitHub page. I read it. Let's build the integration layer you actually want to use.