Business Central MCP Server: Standard APIs and API Queries Now Generally Available

Rolled out to general availability on June 12, 2026, for web-based Worldwide (Standard Multi-Tenant) environments, this update focuses on two foundational capabilities inside Business Central’s MCP server: exposing the full set of standard Microsoft APIs out of the box and adding support for API queries in MCP configurations. While the roadmap entry notes that the update is enabled for end users automatically, enterprise administrators and AL developers should understand exactly how Business Central governs that access, how API objects translate into callable agent tools, and where the technical boundaries still lie.

What Changed in the Business Central MCP Server​

The Model Context Protocol (MCP) is an open standard that defines how AI clients—such as Microsoft Copilot Studio, Visual Studio Code with GitHub Copilot, Claude, ChatGPT, and MCP Inspector—discover and interact with external data sources and business logic through a uniform interface. In Business Central online, the MCP server acts as the governed bridge between those AI hosts and your ERP environment at the dedicated endpoint [url]https://mcp.businesscentral.dynamics.com[/url].

Under roadmap item 576789, Microsoft introduced two major expansions to what the MCP server can surface to connected agents:

• Access to all standard Microsoft APIs: The MCP server can now surface the complete set of standard Business Central APIs (specifically standard API v2.0 pages and queries) directly within an MCP server configuration. Instead of building custom wrapper extensions just to let an agent interact with standard entities and actions, administrators can expose built-in Microsoft API objects out of the box.
• Support for API queries: Beyond standard record-level API pages, administrators can now include Business Central API queries in their MCP configurations. Because API queries can join data across multiple tables and return pre-aggregated, view-only datasets, they give agents a cleaner, more reliable way to handle reporting and analytics questions without pulling raw ledger rows across the wire and hoping the language model sums them accurately.

In practical terms, this shifts Business Central’s MCP implementation from a curated demo capability into a broader integration layer. If a business process or entity is already represented in Microsoft’s standard API v2.0 catalog—or in a published API query—it can be surfaced as an MCP tool without bespoke middleware.

"Enabled Automatically" Does Not Mean Unrestricted Access​

Whenever an enterprise roadmap item says a feature is "enabled for end users automatically," IT administrators rightfully reach for the security manual. Does this mean every Copilot agent suddenly has carte blanche to modify customer records or delete sales orders? Not at all.

According to Microsoft Learn’s Business Central MCP server documentation, the platform relies on a strict multi-layered governance model:

• The Built-in Default Configuration: Out of the box, Business Central includes a default MCP configuration with Dynamic Tool Mode and read-only object discovery turned on. This allows agents to dynamically discover and read eligible API pages and API queries, provided the signed-in user already has Business Central permissions to execute the API object and read the underlying source table data.
• Explicit Write and Action Gating: Agents cannot create, update, or delete records—or trigger bound business actions—unless an administrator with at least the MCP - Admin permission set creates or modifies an MCP server configuration, turns on Unblock Edit Tools, and explicitly grants Allow Create, Allow Modify, Allow Delete, or Allow Actions permissions on the selected API objects.
• User Identity and Entra ID Auditing: The Business Central MCP server authenticates using the OAuth 2.0 Authorization Code flow with Proof Key for Code Exchange (PKCE) backed by Microsoft Entra ID. Every tool invocation runs under the signed-in user's identity and Business Central permission sets, preserving a clear audit trail of who performed each action.

In short, automatic enablement simply means the enhanced MCP server capabilities and the read-only default discovery mechanism are live in your tenant. Any mutating workflow still requires deliberate administrative curation.

Why API Queries Matter for AI Agents and Analytics​

To appreciate why adding API queries to MCP configurations is a significant architectural upgrade, consider how AI agents typically fail when asked analytical questions against an ERP system.

Suppose a finance manager asks an agent for total invoiced and credit-memo sales per customer for the current quarter. If the agent only has access to standard API pages (which map to individual records like Customer cards and Customer Ledger Entries), it has to paginate through potentially thousands of ledger lines and attempt arithmetic inside its context window—or pass massive payloads to a code-execution sandbox.

Business Central objects of QueryType = API solve this at the database and application tier. As documented in Microsoft Learn’s developer reference for API query types, an API query can join multiple data sources (for example, linking the Customer table to Cust. Ledger Entry via a LeftOuterJoin), apply table filters, and aggregate columns using methods like Sum before returning a single, streamlined web-service payload.

One critical distinction for administrators and architects: do not confuse the now generally available API queries in MCP configurations with Business Central’s separate Data Query Tools (Preview) feature. While API queries expose structured, published query objects through the API Tools feature, Data Query Tools (Preview) is a distinct toggle on the MCP configuration page that allows agents to run ad-hoc read-only queries directly against the Business Central database without relying on published APIs. Organizations requiring strict production support should rely on APITools with standard or custom API queries while evaluating the database-level Data Query Tools in preview environments.

How Administrators Configure Standard APIs and Queries​

Setting up an MCP server configuration to take advantage of the full standard API catalog and API queries takes place directly inside the Business Central web client. Based on Microsoft Learn’s configuration guide, here is the end-to-end procedure and the key operational rules to keep in mind:

• Check Prerequisites: Ensure your account holds the MCP - Admin permission set (or equivalent permissions) in Business Central online.
• Create a Configuration: Search for and open the Model Context Protocol (MCP) Server Configurations page, then select New. Give the configuration a clear Name (for example, SalesTeamConfig). Leave the Active toggle switched off while editing—once a configuration is marked Active, it becomes read-only until deactivated.
• Set Edit Controls: If your agent only needs reporting and lookup capabilities, leave Unblock Edit Tools off. If the agent will create orders, update records, or run bound actions, switch Unblock Edit Tools on.
• Activate Server Features: In the Server Features section, locate API Tools and select Activate. If you want agents to discover tools at runtime rather than binding every tool at design time, also activate Dynamic Tool Mode (which requires API Tools to be enabled first). Note that disabling API Tools automatically turns off Dynamic Tool Mode and clears any Discover Read-Only Objects setting.
• Add Standard APIs or API Groups: In the Available APIs section, you can manually add individual API pages, queries, or codeunits by specifying the Object Type, Object ID, and API Version. To leverage the new bulk capability, select Add All Standard APIs to automatically populate standard Business Central API v2.0 pages and queries, or choose Add APIs by API Group to pull in published objects from a specific API group.
• Assign Operation Permissions: For each API object, select the allowed operations (Allow Read, Allow Create, Allow Modify, Allow Delete, Allow Actions). Business Central automatically restricts API queries to read-only operations.
• Validate and Activate: Before flipping the Active switch on, run the built-in Validate action. Validation checks for missing parent API pages, deleted API objects, or conflicting permission states (such as enabling Allow Modify while leaving Allow Read disabled). You can also export and import MCP configurations as JSON files to promote tested setups from sandbox to production.

Under the Hood: Static vs. Dynamic Tool Mode and Client Limits​

How does exposing "all standard Microsoft APIs" interact with AI agent platforms that cap the number of tools an agent can hold? For example, Microsoft Copilot Studio supports up to 128 tools per agent (with 25-30 recommended). Since every allowed operation on an API object generates a separate MCP tool, adding the entire standard API v2.0 catalog in static mode would blow past that ceiling immediately.

Microsoft addresses this through two distinct operating modes in the MCP server:

• Dynamic Tool Mode Off (Static Design-Time Binding): Each permitted operation on an API object generates a uniquely named tool using PascalCase and object metadata: <ActionName>_<EntitySetName>_PAG<ID> for API pages (such as Delete_Customer_PAG30009), _QRY<ID> for API queries, and <ServiceName>_<ProcedureName>_COD<ID> for codeunit actions. Agent makers manually pick and attach specific tools in Copilot Studio.
• Dynamic Tool Mode On (Runtime Discovery): Instead of flooding the client with hundreds of individual object tools at design time, the MCP server exposes three system-level orchestration tools: bc_actions_search, bc_actions_describe, and bc_actions_invoke. At runtime, the agent searches the configuration for relevant API pages or queries, inspects their schema, and invokes them dynamically—neatly bypassing client-side tool-count limits.

Connection headers also play an important role in how Dynamic Tool Mode behaves. When an MCP host connects to [url]https://mcp.businesscentral.dynamics.com[/url], context can be passed via HTTP headers (TenantId, EnvironmentName, Company, and the optional ConfigurationName). While Copilot Studio currently requires EnvironmentName and Company headers (with headerless support planned), clients like Visual Studio Code with GitHub Copilot and GitHub Copilot CLI can omit them. When a supported client omits the Company header, the Business Central MCP server automatically forces Dynamic Tool Mode for API tools, exposes the list_companies tool so the agent can discover available companies, and requires a company parameter on every operational call. Also note that if your Company or ConfigurationName contains non-ASCII characters (such as ø, æ, or å), custom MCP clients must Base64-encode the UTF-8 string using the =?base64?<encodedvalue>?= syntax (Copilot Studio handles this encoding automatically).

Gotchas for AL Developers and System Architects​

Even with standard APIs and API queries available out of the box, developers and architects should watch out for three concrete implementation boundaries documented by Microsoft:

• No ListPart or CardPart API Pages: Only top-level API pages can be added to MCP server configurations. API pages with subtypes ListPart or CardPart are not supported as MCP tools.
• API Pages and Queries Cannot Be Extended: In AL development, you cannot currently write page extensions or query extensions against PageType = API or QueryType = API objects. If a standard Microsoft API page or query is missing a custom field your agent needs, you will still need to publish a custom API page or API query rather than extending the standard object.
• Metadata Drives Agent Accuracy: When an agent searches for tools—especially in Dynamic Tool Mode—the Business Central MCP server generates the tool description from the API object's AL metadata in a strict fallback order: first the AboutText property, then EntitySetCaption, and finally a camel-cased version of EntityName. Developers building custom API queries or pages for MCP consumption should always populate clear, descriptive AboutText properties so the language model selects the right tool on the first try.

By combining one-click access to standard API v2.0 objects with read-only API queries and runtime tool discovery, Microsoft has removed much of the repetitive integration work that previously slowed down Business Central agent deployments. For administrators, the next step is straightforward: review your environment's MCP Server Configurations page, test read-only query discovery against your reporting needs, and use the configuration validator before unlocking any write operations for production agents.

Correction (October 17, 2026): This article originally stated a 70-tool limit. Per Microsoft Learn, agents support up to 128 tools (25-30 recommended).