A field-level walkthrough
SAP Business One RPA via the accessibility tree, not the Screen Scraper Wizard.
Almost every guide for automating SAP Business One starts with a tell: the Screen Scraper Wizard, Click Text against a visible label, and a long list of Send Hotkey calls. UiPath’s own community-blog tutorial for B1 says it plainly: there is no dedicated B1 connector, you treat the client as a generic Windows app and scrape it. That works on a clean install in a clean environment. It also breaks the day a B1 patch reflows a form, a user changes DPI, or someone adds a Beas add-on. The interesting fact almost nobody writes about is that the B1 Win32/.NET client already publishes a full Microsoft UI Automation tree, and reading from that tree is more durable than scraping pixels off it.
Direct answer (verified 2026-05-06)
Yes, you can automate SAP Business One via accessibility. Here is the short version of why and how.
- B1 has no SAP GUI Scripting. That COM API only exists in SAP GUI for Windows (ECC / S/4 frontend), not the B1 client. There is also no first-class B1 RPA connector in UiPath, Power Automate, or Automation Anywhere.
- B1 does publish a UIA tree. Open
inspect.exefrom the Windows SDK, hover any field, and you will see ControlType, Name, and AutomationId populated for most controls. - UIA-based RPA is more durable than the documented path. The Screen Scraper Wizard + Click Text + Send Hotkey path UiPath recommends breaks on label renames, DPI changes, and theme changes. UIA locators resolve through AutomationId first and survive most of those.
Sources: UiPath community-blog tutorial on B1 automation, Microsoft UI Automation overview.
Why SAP Business One is its own automation problem
The single most common confusion in this space is collapsing all SAPs into one bucket. Classic SAP GUI for Windows (the ECC / S/4HANA frontend) ships a documented COM scripting interface called SAP GUI Scripting. Once your Basis team flips sapgui/user_scripting=TRUE on the application server and on the client, you can drive the GUI from VBScript or any COM client.
SAP Business One is a separate codebase. It is the SMB ERP, written in C++/.NET, with its own form rendering engine and its own SDK (SAPbouiCOM for the UI side, DI API for the data layer). It does not expose anything resembling SAP GUI Scripting. UiPath’s own tutorial says it directly:
“Unlike the standard SAP GUI, it’s not necessary to perform any changes to settings, like enabling scripting, since Business One automation doesn’t have a dedicated type of automation.”UiPath community blog, Automations for SAP Business One
That is the polite version. The actual recommended path in that same tutorial is UI Classic mode plus the Screen Scraper Wizard plus Click Text plus Send Hotkey. None of those read the accessibility tree the B1 client actually publishes.
What makes B1 specifically different
- No SAP GUI Scripting. The sapgui/user_scripting profile parameter and the GuiApplication COM API only exist inside SAP GUI for Windows (the ECC / S/4 frontend). The B1 client is a separate codebase.
- DI API exists, but it is COM, single-threaded, and requires the B1 client install on every runtime machine. Throughput is bounded by one DI session per process.
- Service Layer is HANA-only. Customers running B1 on Microsoft SQL Server (still the majority of mid-market deployments) cannot use it.
- B1 add-ons commonly intercept menu and form events at the SAPbouiCOM layer, which means custom screens for Boyum B1, Beas, Produmex Food are still rendered through the same UI host. Anything that drives the host through UIA inherits coverage of those add-ons for free.
- The B1 Win32/.NET client renders standard Windows controls. ControlType, Name, AutomationId, ValuePattern, and SelectionPattern all populate. inspect.exe and Accessibility Insights confirm this in 30 seconds.
The two paths, side by side
Toggle between them. Same goal: type a customer code into the A/R Invoice form, then advance through the line item grid. The first version is what the documented B1 RPA tutorials produce. The second version is what reading the UIA tree gives you.
A/R Invoice header entry
// What the documented B1 RPA path looks like // (UiPath B1 community blog tutorial, 2026) // 1. UI Classic mode required (no Modern Design connector for B1) // 2. Open Screen Scraper Wizard // 3. Use Click Text on the visible label "Customer" // 4. Send Hotkey: Tab Tab Tab F2 ... // 5. OCR fallback when Click Text misses // a. Increase OCR confidence threshold // b. Add manual delays around redraws // c. Hand-tune coordinates per environment ClickText("Customer"); SendHotkey("{TAB}{TAB}{TAB}"); TypeInto.SendWindowMessages("C20000"); // breaks when: // - the form theme changes // - the user has a different DPI // - a popup steals focus mid-flow // - B1 9.3 -> 10.0 reflows the line item grid
- OCR confidence has to be tuned per environment
- Click Text breaks on label translation or rename
- Hotkey sequences break on focus-stealing popups
- B1 9.3 to 10.0 grid reflow forces a full re-record
Confirm it on your own B1 instance in 4 steps
Before you commit to any RPA approach for B1, verify the surface yourself. The whole exercise takes less than ten minutes and the only tool you need is free.
Inspect the UIA tree of a live B1 form
- 1
Open inspect.exe
Ships with the Windows SDK. Path is C:\Program Files (x86)\Windows Kits\10\bin\10.0.x.x\x64\inspect.exe. Free. No license check.
- 2
Launch SAP B1 client
The Win32 host process is SAP Business One.exe. Sign in to your B1 instance and open a transaction window such as A/R Invoice or Journal Entry.
- 3
Hover any field
inspect.exe shows ControlType, Name, AutomationId, BoundingRectangle, and IsKeyboardFocusable for the element under the cursor. The values you see are the ones any UIA-based runtime will see.
- 4
Confirm the property pattern
Most editable B1 fields are ControlType.Edit with a stable Name pulled from the B1 form definition. Buttons are ControlType.Button. The Items list, Business Partner combo, and matrix cells expose ValuePattern and SelectionPattern. That is enough for deterministic locators.
The point of step 4 is the falsifiable part. If the controls in the form you care about populate ControlType, Name, and AutomationId in inspect.exe, a UIA-based runtime can drive them deterministically. If a specific control does not (we still see this on a few matrix cells in older B1 builds), the locator falls back to the parent table plus row/column index, which is still more durable than a pixel-coordinate hit test.
“We moved an LG-customer F&B chain from UiPath to Mediar for their B1 workflows. Their CFO told the board they're now saving 70% on costs.”
Mediar customer story, F&B chain on SAP Business One
What a real workflow file looks like
The runtime artifact is a TypeScript file. The recording pass writes a createWorkflow call with a zod input schema and a list of MCP steps. Each step is one UIA interaction. There is no LLM in the runtime, the model only runs once during the offline recording-processing pass to convert the captured event stream into the file below. After that file is checked in, replay is deterministic.
A reviewer can diff this file the way they would diff a stored procedure. The steps are listed as comments above for readability; in the shipped workflow each step is an actual MCP tool call object. The whole point of this shape is that an audit team in a regulated F&B or finance environment can sign off on the workflow before it runs in production, which is harder to do when the automation is a recording inside a proprietary RPA studio.
The numbers from the B1 deployments we have actually shipped
These are not press-release numbers. The 70 percent figure comes from the F&B chain CFO’s board update. The four-surface count comes from the B1 documentation itself. The dollar number is the published runtime price on mediar.ai.
When the accessibility-tree approach is the wrong answer
Honest version: it is not always the right answer.
- If your workload is steady-state batch posting at high volume and you have ABAP/B1 SDK developers in-house, the DI API or the Service Layer (HANA only) is faster per record. Accessibility-driven automation is still bound by the speed of the UI redraw.
- If the workflow lives entirely inside a single B1 transaction and you are happy with a license-locked unattended bot from a traditional RPA vendor, the screen scraping path is a known quantity. It will cost more and break more often, but the operational pattern is familiar.
- If you need to run thousands of concurrent posts with sub-second latency, neither front-end automation nor the single-threaded DI API will hit that bar. That is a queue plus Service Layer (or a custom ABAP add-on) problem, not an RPA problem.
The shape of problem the accessibility-tree approach genuinely beats every other path on is the common B1 mid-market case: a workflow that opens something outside B1, validates it, posts a document into B1, and writes the resulting DocNum back into a non-B1 system. That boundary is where DI API stops, Service Layer stops, and screen scraping breaks.
Frequently asked, with sources
Frequently asked questions
Does SAP Business One support the same scripting interface as SAP GUI for Windows?
No. SAP GUI Scripting is a COM API exposed by the SAP GUI for Windows frontend (saplogon.exe) and is gated by the sapgui/user_scripting profile parameter on the application server. That entire surface is specific to ECC and S/4HANA classic GUI. The SAP Business One client is a separate Win32/.NET application, and there is no equivalent scripting API. Any RPA tutorial that begins with 'enable scripting' is talking about ECC, not B1. The UiPath community-blog tutorial for B1 explicitly notes the lack of a dedicated connector and points readers at the Screen Scraper Wizard, Click Text, and Send Hotkey activities instead.
What does the Microsoft UI Automation tree actually expose for the B1 client?
Run inspect.exe (ships with the Windows SDK) against a live B1 session and you will see the form rendered as a tree of UIA elements. Most editable fields are ControlType.Edit with a Name property pulled from the B1 form definition (Customer, Posting Date, Item No., Quantity, Total LC, etc.). Buttons are ControlType.Button. The line items grid is ControlType.Table where each cell exposes ValuePattern. Tabs, comboboxes, and the matrix all populate Name and AutomationId for most controls. The reason this works is that the B1 client uses standard Windows controls under the hood, and Windows publishes the accessibility tree for those controls automatically. Mediar reads from that tree the same way a screen reader would.
Why is reading the accessibility tree more durable than the UiPath-recommended path?
The Screen Scraper Wizard plus Click Text plus Send Hotkey path resolves controls by visible pixel content (OCR), by visible text label search, or by a fixed sequence of key presses. All three break in predictable ways. OCR breaks when the user changes DPI or the theme changes. Click Text breaks when a form translation flips Customer to Cliente, or when an add-on relabels a field. Hotkey sequences break the moment any popup steals focus. Reading the UIA tree resolves elements by AutomationId first, then Name plus role, then position relative to a parent window, then visible label as a fallback. Three of those four strategies survive a label rename, a theme change, or a DPI shift. The fourth is essentially the Click Text approach, used only as a last resort.
What about the DI API or the Service Layer? Is the front-end approach really the right answer?
The DI API is the cleanest answer when you have it. It is COM-based, single-threaded, and requires the SAP Business One client install on every machine that runs the integration. For a steady-state batch process that posts a few hundred documents an hour, that is fine. For a workflow that spans multiple desktops, that includes a non-B1 step (open a PDF, validate against an Excel file, then post into B1, then write the result into a Slack channel), or that has to be auditable as a UI-level recording, accessibility-API automation is more honest. The Service Layer is the modern HTTP API but it is only available on the HANA edition of B1. Customers running B1 on Microsoft SQL Server (still the majority of mid-market deployments) cannot use it. That leaves the front-end as the universal surface.
Will accessibility-tree automation work with B1 add-ons (Boyum B1, Beas, Produmex)?
Yes, in almost every case we have shipped. B1 add-ons hook the SAPbouiCOM event model and render their own forms into the same UI host process. Because UIA reads the host's window tree, custom screens added by Boyum, Beas, and Produmex Food show up as additional ControlType nodes with their own Name and AutomationId values. We have automated F&B chain workflows that cross between native B1 forms and Beas production work orders inside one workflow file, and the line item entry inside a Beas screen looks identical to UIA as the line item entry inside a native A/R Invoice. The runtime does not need to know whether a node is core B1 or an add-on.
How do I confirm this on my own B1 instance before I commit to the approach?
Open inspect.exe (it ships with the Windows SDK at C:\Program Files (x86)\Windows Kits\10\bin\10.0.x.x\x64\inspect.exe), set the mode to Tree View or Hover Mode, launch SAP Business One, and walk through the form you want to automate. Hover the Customer field on an A/R Invoice. You should see ControlType: Edit, Name: Customer (or the B1 translation of it), and a populated AutomationId on most builds since B1 9.3. Hover the Add Row button. You should see ControlType: Button, IsKeyboardFocusable: true, and a real BoundingRectangle. If the elements you care about are populated, you can drive them with any UIA-based runtime. If a specific element shows as Unknown ControlType (it happens on some matrix cells in older B1 versions), the runtime falls back to the parent grid plus row/column index.
What is the cost vs UiPath on a real B1 deployment?
The number we publish is from an LG-customer F&B chain that moved off UiPath onto Mediar for their B1 workflows. The CFO told the board they are saving 70 percent on costs. The arithmetic is straightforward: Mediar bills $0.75 per minute of runtime against the workflow, with no per-seat licensing, no Studio licenses, no Orchestrator. The $10K turn-key program fee converts to credits with a bonus, so it is effectively prepaid usage. UiPath at the equivalent volume runs unattended-bot licensing plus Orchestrator plus Studio plus implementation services, and the comparable annual cost is several multiples of the runtime number.
Is the runtime open source so I can verify it before deploying?
The execution layer is. The Terminator SDK that performs the UIA calls and the locator resolution lives at github.com/mediar-ai/terminator under MIT. It exposes the MCP tools (type_into_element, click_element, set_value, get_text) the workflow file references. You can drive a SAP Business One window with Terminator alone, no Mediar cloud, no orchestration, just the UIA primitives. The recording pipeline, the cloud orchestrator, and the no-code workflow builder at app.mediar.ai/web are commercial. Teams that want to wire B1 directly into their own queue or message bus can build on Terminator without paying for the SaaS layer.
Does the workflow file remain valid after a B1 patch?
Most of the time, yes, because UIA properties are stable across B1 patches more often than pixel positions are. The cases where the workflow has to be re-recorded are usually when SAP renames a field across a major version (B1 9.3 to 10.0 reflowed the line item grid, for example), or when a B1 add-on inserts a new screen step in the middle of a recorded path. The runtime emits structured failures with the parent window title and the unresolved step id, so a human can open the recording app on the failing step and capture the new branch. Silent retry is disabled by default for B1 workflows because posting half an A/R Invoice is worse than not posting it.
How is this different from your other SAP automation pages?
The other SAP pages on this site cover SAP GUI for Windows (the ECC and S/4HANA classic frontend), where automation can lean on the SAP GUI Scripting COM API as a fast path. SAP Business One does not have that fast path. The runtime tools are the same (Mediar drives both through UIA), but the trade-offs are different: ECC has at least one official scripting interface, B1 does not. That is why the B1 deployment story leans harder on the accessibility tree, and why most B1 RPA projects fail when they try to copy the ECC playbook.
Run the inspect.exe test on your B1 instance, then book 30 minutes.
If the UIA tree is populated for the forms you care about (it almost always is), we can record one of your workflows on the call and have a deterministic replay running by the end of the week.
Adjacent reading on SAP, accessibility-API automation, and the legacy desktop layer.
Related on Mediar
SAP data entry automation: one journal entry, traced from PDF to F-02
The same Windows UI Automation primitives, applied to the SAP GUI for Windows side (ECC / S/4) instead of the B1 client. Useful as a comparison.
How to automate SAP
The honest decision tree across the four SAP runtime surfaces (classic GUI, Fiori, Business One, ByDesign). Read this first if you are not sure which SAP you are on.
AI agents for legacy desktop systems with no API
Why front-end automation through the accessibility tree is the universal answer for systems that never got a public API in the first place.