← All posts
UnpackedBC29.0DEVCONSULT

BC29 drops SOAP on Microsoft UI pages, BC30 drops OData on them: find your callers first

BC29 ends SOAP on Microsoft UI pages and BC30 ends OData on them. How to find every Business Central integration that still calls them, and what to move it to.

Published 8 min read

TL;DR

  • SOAP on Microsoft UI pages has been off by default since 26.0. In 29.0 the switch to turn it back on is gone. In 30.0 OData on those pages goes too.
  • Your own pages, API pages and the standard api/v2.0 endpoints are not affected.
  • Telemetry finds the callers: RT0053 flags deprecated SOAP calls, RT0008 shows the OData traffic that breaks on 30.0.
  • Move each caller to a standard API, a custom API page, or, as a bridge, a copy of the page in your own extension.

If an integration reads Customer Card, Item List or Sales Order as a web service, it has one or two updates left. SOAP on Microsoft UI pages has been blocked by default since version 26.0, and 29.0 removes the switch that let admins unblock it. Version 30.0 (2027 release wave 1) does the same to OData on those pages. Microsoft first flagged SOAP on UI pages back in 2021, so none of this is new. The hard part is finding out which integrations still call these endpoints. Do that first; the AL work is the easy part.

What changed

SOAP OData V4
UI page from a Microsoft app (Base Application, System Application, first-party apps) Off by default since 26.0, removed in 29.0 Removed in 30.0
Page from your per-tenant extension (PTE) or an AppSource app Works, but SOAP itself is deprecated Works
API pages (api/v2.0, custom API pages) n/a Works

A “Microsoft UI page” here means any regular (non-API) page in an app whose publisher is Microsoft. Customer Card (page 21) is one. A page you wrote in a PTE is not, even if its source table is Customer.

How the SOAP part played out:

  • 26.0 to 28.x: the feature key Feature: Disable SOAP web services on Microsoft UI pages is on by default, so SOAP calls to Microsoft UI pages already fail. They still work only where an admin turned the key off in Feature Management.
  • 29.0: the key is mandatory, so it’s on everywhere and can’t be turned off. Online admins can schedule 29.0 within the five-month update period, which the 29.0 release notes say ends in February 2027.
  • 30.0: OData calls to Microsoft UI pages fail as well.

One page in the docs disagrees. The feature key article, updated in September 2026, still says the capability and the key “will be removed in Business Central version 30.0”. The platform deprecation list, the 29.0 release notes and the SOAP web services articles all say 29.0. Plan for 29.0.

The notices name UI pages only. Queries published over OData and codeunits published over SOAP aren’t mentioned. SOAP as a whole has been deprecated since 2021, though, so a SOAP codeunit isn’t a safe place to land either.

Find your callers before you fix anything

The Web Services page tells you what is published. It doesn’t tell you what is used, and it has no publisher column. Online environments ship with a set of services published by default, and projects add more over the years, so the list often has entries nobody can explain. Object IDs give you a rough first pass, since most Microsoft pages are below 50,000, but they don’t prove who the publisher is.

Telemetry answers the real question. If the environment sends telemetry to Application Insights, two events cover this change.

RT0053, “Deprecated endpoint called”, has existed since 26.0 for exactly this case: it fires when a SOAP call hits a Microsoft UI page. You’ll only see it where the feature key was turned off, because elsewhere those calls already fail.

traces
| where timestamp > ago(30d)
| where customDimensions has "RT0053"
| where customDimensions.eventId == "RT0053"
| summarize calls = count(), lastCall = max(timestamp)
    by environment = tostring(customDimensions.environmentName),
       objectId = tostring(customDimensions.alObjectId),
       objectName = tostring(customDimensions.alObjectName),
       endpoint = tostring(customDimensions.endpoint),
       // the docs spell this dimension two ways; take whichever is filled
       message = coalesce(tostring(customDimensions.deprecationMessage),
                          tostring(customDimensions.depricationMessage))
| order by calls desc

RT0008, “Web service called”, logs every incoming call with its protocol and the publisher of the object that ran. Use it for the OData side, which breaks on 30.0:

traces
| where timestamp > ago(30d)
| where customDimensions has "RT0008"
| where customDimensions.eventId == "RT0008"
| extend category  = tostring(customDimensions.category),
         objectType = tostring(customDimensions.alObjectType),
         publisher  = tostring(customDimensions.extensionPublisher)
| where category in ("ODataV4", "SOAP")
| where objectType =~ "page" and publisher == "Microsoft"
| summarize calls = count(),
            lastCall = max(timestamp),
            sampleEndpoint = take_any(tostring(customDimensions.endpoint))
    by environment = tostring(customDimensions.environmentName),
       category,
       objectId = tostring(customDimensions.alObjectId),
       objectName = tostring(customDimensions.alObjectName)
| order by calls desc

The service name in sampleEndpoint usually tells you which integration a row belongs to.

Keep two limits in mind. Telemetry only covers the period since it was switched on, so a job that runs once a quarter may not show up in 30 days; widen the window if you can. And if the environment has no Application Insights connection string yet, set one up now, so the data is there when you need it.

For developers

Pick the replacement per caller, in this order:

Caller needs Use
Data the standard API already exposes (customers, items, sales orders, journals…) Standard API v2.0
Fields or tables the standard API doesn’t have A custom API page in your extension
SOAP, or a client you can’t change at all A copy of the page in your extension, as a bridge

With the first two options the URL changes, and so do the field names: the page 21 service returns No and Name, while the customers API returns number and displayName. The client has to change too, so bring its owners in early.

# Before: page 21 published as "Customer" (breaks on 30.0)
GET https://api.businesscentral.dynamics.com/v2.0/<tenant>/<environment>/ODataV4/Company('CRONUS%20USA%2C%20Inc.')/Customer

# After: standard API v2.0
GET https://api.businesscentral.dynamics.com/v2.0/<tenant>/<environment>/api/v2.0/companies(<companyId>)/customers

# After: the custom API page below
GET https://api.businesscentral.dynamics.com/v2.0/<tenant>/<environment>/api/acme/integration/v1.0/companies(<companyId>)/customers

A custom API page

When an integration needs a field the standard customers API doesn’t return, write a small API page with exactly the fields it reads. This one is read-only. In Business Central online, DataAccessIntent = ReadOnly sends its reads to the read-only replica. That keeps a frequently polled endpoint off the primary database, but the replica can lag slightly behind.

page 50100 "Customer API BCU"
{
    PageType = API;
    APIPublisher = 'acme';
    APIGroup = 'integration';
    APIVersion = 'v1.0';
    EntityName = 'customer';
    EntitySetName = 'customers';
    EntityCaption = 'Customer';
    EntitySetCaption = 'Customers';
    SourceTable = Customer;
    ODataKeyFields = SystemId;
    Editable = false;
    InsertAllowed = false;
    ModifyAllowed = false;
    DeleteAllowed = false;
    DataAccessIntent = ReadOnly;
    Extensible = false;

    layout
    {
        area(Content)
        {
            repeater(Records)
            {
                field(id; Rec.SystemId) { }
                field(number; Rec."No.") { }
                field(displayName; Rec.Name) { }
                field(countryRegionCode; Rec."Country/Region Code") { }
                field(email; Rec."E-Mail") { }
                field(blocked; Rec.Blocked) { }
                field(creditLimitLCY; Rec."Credit Limit (LCY)") { }
                field(balanceLCY; Rec."Balance (LCY)") { }
                field(lastModifiedDateTime; Rec.SystemModifiedAt) { }
            }
        }
    }
}

balanceLCY is a FlowField, calculated for every row. Clients that don’t need it should leave it out with $select.

API pages don’t go on the Web Services page. They’re available as soon as the extension is installed (on-premises, API services must also be enabled on the server).

A copy of the page, as a bridge

Some clients can only speak SOAP, or belong to a vendor who won’t change anything. For these clients, add a page with the same fields to your extension and publish it as the web service. Copy only the fields the client uses, and keep their names exactly as they are on the original page. The full Customer Card has hundreds of lines you would then maintain yourself.

This keeps the client alive past 29.0 or 30.0. It doesn’t make SOAP safe: SOAP itself is deprecated, so treat the copy as time bought to plan a real migration.

page 50101 "Customer Card WS BCU"
{
    PageType = Card;
    SourceTable = Customer;
    Caption = 'Customer (web service)';
    UsageCategory = None;
    ApplicationArea = All;

    layout
    {
        area(Content)
        {
            group(General)
            {
                field("No."; Rec."No.") { }
                field(Name; Rec.Name) { }
                field("Country/Region Code"; Rec."Country/Region Code") { }
                field("E-Mail"; Rec."E-Mail") { }
                field(Blocked; Rec.Blocked) { }
                field("Credit Limit (LCY)"; Rec."Credit Limit (LCY)") { }
            }
        }
    }
}

codeunit 50102 "Install Web Services BCU"
{
    Subtype = Install;

    trigger OnInstallAppPerDatabase()
    var
        WebServicesBCU: Codeunit "Web Services BCU";
    begin
        WebServicesBCU.Publish();
    end;
}

codeunit 50103 "Upgrade Web Services BCU"
{
    Subtype = Upgrade;

    trigger OnUpgradePerDatabase()
    var
        WebServicesBCU: Codeunit "Web Services BCU";
    begin
        WebServicesBCU.Publish();
    end;
}

codeunit 50104 "Web Services BCU"
{
    Access = Internal;

    procedure Publish()
    var
        TenantWebService: Record "Tenant Web Service";
        WebServiceManagement: Codeunit "Web Service Management";
        ServiceNameTok: Label 'Customer', Locked = true; // the service name the client calls today
    begin
        WebServiceManagement.CreateTenantWebService(
            TenantWebService."Object Type"::Page, Page::"Customer Card WS BCU", ServiceNameTok, true);
    end;
}

permissionset 50100 "Integration BCU"
{
    Assignable = true;
    Caption = 'Integration (BCU)';
    Permissions =
        page "Customer API BCU" = X,
        page "Customer Card WS BCU" = X,
        tabledata Customer = R;
}

A few details in this code matter:

  • The install codeunit runs only on first install. Most PTEs are already installed in the customer’s environment, so the upgrade codeunit makes the same call when you deploy a new version. Both run per database because web service definitions aren’t per company.
  • SOAP and OData URLs are built from the service name, not the page ID. CreateTenantWebService finds the entry by object type and service name and points it at your page. Publish the copy under the name the client already uses, and the URL and the SOAP namespace stay the same. If that name belongs to a system-wide default service rather than a tenant one, pick a new name; the client then has to switch to the new URL. Test this in a sandbox before production.
  • Running Publish again is safe, but it sets the service back to published even if an admin unpublished it.
  • The permission set is for integration users with narrow permissions. If the client writes data, it needs more than R on Customer. If it only reads, add Editable = false to the copy so the service doesn’t offer create, update and delete.

For consultants

Before you schedule 29.0 for a customer, and again before 30.0:

  1. Open Feature Management in production and find Feature: Disable SOAP web services on Microsoft UI pages. If it’s enabled (the default), SOAP on Microsoft UI pages is already blocked there and 29.0 changes nothing for SOAP; your work is the OData part for 30.0. If someone turned it off, there are SOAP callers to move before 29.0.
  2. Ask whoever owns telemetry to run the two queries above, or send them the telemetry docs.
  3. Compare the results with the Web Services page. Leave Microsoft’s default services alone. Among your own entries, anything published but not called is a candidate to unpublish.
  4. For each endpoint that is called, write down who owns the caller: the customer’s IT, an ISV connector, a Power BI report, an Excel workbook. Flows built on the standard Business Central connector for Power Automate use the APIs and aren’t affected.
  5. Create a sandbox as a copy of production. It starts on production’s version, so update it to 29.0 and have each owner test against it. For OData, test on a 30.0 preview sandbox when one is available to you.
  6. Schedule the production update after the SOAP callers are moved. Keep the OData list for 30.0.

What to tell the customer:

“Some of your connections to Business Central read data through screens that were designed for people, not for other systems. Microsoft is switching that off over the next two updates. Before each one, we’ll check which connections are affected and move them to the interfaces Microsoft provides for integrations.”

Gotchas

  • Default web services online. Business Central online publishes a set of web services out of the box, and Power BI reports and Excel workbooks have been built on them for years. Where a default service is a Microsoft UI page, it stops answering OData on 30.0. Many defaults are queries, which the notices don’t cover, so check each service on its own instead of judging the list as a whole.
  • Edit in Excel. It uses OData on the page you’re looking at. The deprecation notices don’t say whether it’s affected. Test it on a 30.0 preview before telling users anything.
  • On-premises. The same rules apply, and they take effect when you upgrade the server to 29.0 or 30.0. There’s no update window to plan around, only your own upgrade date.
  • Copied pages don’t follow Microsoft. When Microsoft adds or renames a field on Customer Card, your copy stays as it was. That’s stable for the client, and it’s also maintenance you now own.

What to do now

  • Developers: run both queries on every environment you support. Move SOAP callers first; prefer api/v2.0 and write a custom API page when it falls short.
  • Developers: if your extension publishes Microsoft UI pages in its install code or web service XML, change it to publish your own page.
  • Consultants: check the feature key in Feature Management and add “web services on Microsoft UI pages” to your 29.0 and 30.0 update checklists, with an owner per caller.
  • Consultants: make sure every production environment sends telemetry to Application Insights, so the next check has data behind it.

Sources

  1. Deprecated features in the platform
  2. Update 29.0 for Business Central 2026 release wave 2
  3. Disable SOAP web services on Microsoft UI pages feature key
  4. SOAP web services
  5. Analyzing incoming web service request telemetry
  6. Publishing a web service

#web-services#integration#odata#soap#api#telemetry#upgrade