So, we have a new ‘Modern’ Web Browser control, some people have also referred to it as the Edge Web Browser control! Well that is if you are running MS365 and using the BETA or Current Update Channels running build 16.0.16327.20214 or greater.

You can check out the complete Modern Web Browser release cycle by reviewing:

I thought, I would start documenting the new ‘Modern’ Web Browser control, like I had done for its predecessor:

 

In the this article, I touch upon:

• Design Approach
• Overview
• Known Bugs and Limitations
• Improvements
• Compatibility With Older Access Versions & Runtime
• Caution Regrading The Use Of The RetrieveJavascriptValue Method
• Trusted Domains
• Control Source VS Navigate
• Expected URL Format & Behaviors
• Static/Hard Coded URLs
• URLs From A Table
• URLs From VBA
• Content From a Local File
• Dynamic Content on the Fly
• Opening a Blank Page
• Getting Browser Information
• Retrieving the Current Page’s URL
• Retrieving the Current Page’s Title
• Retrieving a Page’s HTML Source Code
• Saving a Page
• Refreshing the Webpage
• Executing Code on the Webpage
• Managing Cookies
• Navigate to the Previous Page, Go Back
• Navigate to the Next Page, Go Forward
• Zooming In and Out of the Web Page
• Stopping Links From Opening Popup Windows
• Printing the Webpage
• Retrieving Information From The WebPage
• Retrieving the Current Page’s Meta Values
• Navigating The File System
• Modern Web Browser Control Bugs
• Q & A
• Demo Database
• Additional Articles/Demos
• Additional Resources
• Acknowledgements
• Page History

 

Design Approach

I quickly wanted to mention that the Modern Web Browser control seems to store certain information in memory, cached in some shape or form. Even after closing the form and reopening it, it would seem to keep prior settings long after they were changed.

On a number of occassions I have made changes while doing development which should have resolved an issue only to find it didn’t…. Eventually, I would perform a Compact and Repair and that same code worked just fine afterall.

All of this just to say, I highly urge you to frequently close the database completely, or perform a Compact and Repair to flush the memory/cache or else you may be working for nothing!
 

Overview

I wasn’t originally going to include some of this, but when I found out that it was already public information (in a public video) I decided to add this information for those that like to know and understand the inner workings of things.

If you watch the DAAUG video (link below in the Resources section) from 2022-10-18, you can gather some general information about the control itself.

Basically, the new Microsoft Access Modern Web Browser control moved away from the old MSHTML (supported until 2029 – same thing IE uses) used in the previous Web Browser control and moved toward using WebView2 Edge Chromium instead. By doing so, it can now handle modern CSS, JS, … bringing us into being able to support the modern world wide web content!

WebView2 powers the new control and is part of Office.

Joe Jimenez, of the Microsoft Access Dev Team and I believe the primary developer of the new control, also briefly elaborates that the new browser lives upon OSF (Office Solution Framework), from my understanding it is built something like: OSF -> WebView2, but I could be wrong here though, listen for yourself @ around minute the 1:04:20 mark to his brief explanation of the overall architecture.
 

Known Bugs and Limitations

Before going any further, I thought we should briefly touch upon any known limitations of the Modern Web Browser:

• Only available to MS365 users (currently BETA or Current Update Channel only) and not backwards compatible!
• Trusted Domains – Review this carefully to see if this is a deal breaker for you, or not!
• There is presently a 2048 character limit when defining the Web Browser’s .ControlSource via VBA (this won’t be an issue for most uses, but there are cases where this can be a deal breaker)
• It cannot currently handle local file paths/names that include spaces
• If viewing a PDF file, there does not seem to be any means to access the annotation toolbar (this seems to be a WebView2 limitation – not just Access)
• Right-clicking on the Web Browser control, selecting Build Event, followed by selecting Code Builder will freeze and then crash Access. You must instead select the Web Browser control and then use the Property Sheet to select the Event you wish to work with and use the … button to add code.
• There is a bug with the .Navigate method. It would seem it does not allow one to switch between local content (file) and www URLs (website). So if you start by using one, you cannnot then switch to use the other. You must close and reinitialize the form. Or perhaps supperimpose two controls, one for local content and one for www URLs, and change the visibility based on the content.
• If you use the dialog/wizard to select a local file as the source, it does not prepend the file path/name with the required https://msaccess and thus will not render the local file in the Modern Web Browser control, instead it will open it in your actual browser application.
• JS is not fully supported. The more I test and try advanced things, the more I find that JS commands that don’t work. For most common automation it may not pose any problems, but it does happen when code that works just fine in any full fledge browser does not in the Modern Web Browser control.
• Help using F1 does not work (neither in the Web Browser control’s property sheet, nor in VBA when on Web Browser object methods/properties). Over the course of a couple days now, only once has it actually worked properly.
• As of the date of publishing this article, Microsoft provides not a single example of how to use the various methods/properties… part of the reason I decided to create this page, to illustrate how to actually use them and save you the frustrations I went through to get things functional.
• I’ve been finding the control to be slow at times, freezing my installation, …
• Another oddity I’ve found is that the control does not seem to recognize any of Edge’s shortcut keystrokes. So to change the zoom, go back, go forward, … you’ll have to code it all yourself. It is a Pro and a Con depending on how you view things.
• The other MAJOR change/hurdle, to me at least, has been the loss of the WebBrowser.Object and thus the WebBrowser.Object.Document to be able to directly interact with the page. Several abilities have been lost because of this limitation, and/or other require more ‘creative’ and convoluted solutions to achieve the same thing. This also means that most, if not all existing code is not transferable and will need massaging, if not complete rewriting. Because of this, we can no longer bind directly to the page elements to detect say when a button is clicked! I cannot over state how big of a loss this is for advanced automation purposes.

Update 2023-05-29 :: Eric reported in the comments that the control doesn’t work with SharePoint site URLs. So we have made a step forward, but there appear to still be some serious issues!

 

Improvements

The obvious improvement is we are running a modern browser, so:

• No more need for registry hacks (still not sure if we can force a specific version, I haven’t looked into that yet)
• No need for using the MOTW or the X-UA-Compatibility Meta Tag
• Handles modern CSS, JS, JQuery properly – thus no more JS errors!
• Access to Developer Tools! We can now right-click on a page within the Web Browser control to Inspect the page and access all the modern day developer tools.
• The new Modern Browser Control works properly in Forms and Reports, even continuous ones! This is HUGE!
• Not an improvement, but just to mention that I also like being able to drop a web browser control into a form/report and then set its’ anchoring (Horizontal and Vertical) to Both so the control fills the form/report regardless of the size/resolution. That said, there does appear to be an issue when you resize the form, the control adjusts in size, but the render website does not!

 

Compatibility With Older Access Versions & Runtime

Older Access Versions

Should you develop a solution that includes the new Modern Web Browser and then distribute it to users running older versions of Access, what they will see is nothing.

That’s right, nothing appears at all, even in design view.

So the database, at least in my quick testing, will otherwise function just fine, but where there should be a Modern Web Browser control, now, there will be nothing displayed.

HOWEVER!, you may end up with compilation issues depending on coding!!! For instance, if you create code that you Dim variables ‘As Access.Edge’ then your code will no longer compile in earlier versions of Access!!! So backwards compatibilty is iffy. One thing you can do in such cases is to Dim the variable ‘As Object’ or perhaps As ‘Access.Control’.

Runtime

The following come directly from the Access Dev Team when I put the question to them:

If you wish to use this control in a Runtime environment then you will need to install/use the MS365 Runtime which you can download from:

and be sure to be running build 16.0.16327.20214 or greater.

The A365 Runtime will support the new Edge web browser control when Version 2305 is released, which should be early next week (week of May 29th, 2023).
 

Caution Regrading The Use Of The RetrieveJavascriptValue Method

So, as such, I highly recommend you assign the result of any RetrieveJavascriptValue calls to a string variable and test it before actually trying to work with it. Do not use RetrieveJavascriptValue directly in your code or it may not behave as you might expect, and/or might crash your database solution altogether. Instead, do something like:

Dim sRetVal              As String

sRetVal = Me.EdgeBrowser0.RetrieveJavascriptValue("WhateverYourJSCommandIs")
If sRetVal = "RetrieveJavascriptValue timed out. Please verify the JavaScript expression supplied is valid." Then
    MsgBox "There is a critical problem with Access." & vbCrLf & vbCrLf & _
           "Contact your database administrator for further assistance with this error.", _
           vbCritical Or vbOKOnly, "Operation Aborted"
    Exit Sub 'Exit Sub, Exit Function or Goto Error Handler, the choice is yours
End If

'We are here because RetrieveJavascriptValue  worked properly
'    Thus, you can then use sRetVal in the rest of your code

 

Trusted Domains

Another big change is the addition of the need to define the Trusted Domains property to be able to navigate to another page! Otherwise, the click URL will be opened in your full blown Web Browser.

So in short, Microsoft has taken the “Browser” out of “Web Browser”. In short, unless you set up Trusted Domains, you have a web page viewer, not a Browser since you won’t be able to browse different urls in Access!

I’m assuming for security purposes? Microsoft has deemed it necessary to restrict link redirection unless the domain is defined as a Trusted Domain. So if a page loads and the user click on a link then the link will open in Edge directly, rather than the Modern Web Browser Control itself.

That said, I truly don’t get why this is, one way or another they are still opening the site, so why not where the request was actually made?! This is simply ridiculous!

Furthermore, this also means that the New Modern Web Browser control cannot support URL redirection! So for things like SharePoint, Power BI, … you have to define every URL along the chain to get it to work. So authentication URLs must be defined or else it won’t work in the new control. It’s all just a big mess.

Beyond which, if I click on a link to a URL outside of the current domain which isn’t in the Trusted Domains, then it open externally to Access (in your full blown browser). Yet, I can right-click on the link to copy the URL and then navigate to the same address, and that is fine?! The logic simply makes absolutely no sense whatsoever!

This mean you need to create a table, any table, but the first column of the table must be the field/column that hold the authorized URL/Domains. Then you need to set the Web Browser control’s Trusted Domain property to this table.

I had hoped we could use the Before Navigate event for this, get the URL and add it to the table automatically, but it turns out not to be the case. So for me, this is a real deal breaker when it comes to using this new control freely!

One could however, upon loading a page, extract a listing of all the link/button hrefs and push them to the table automatically to get around this issue, but I haven’t done so, yet.

It appears that changes to the Trusted Domains table only take effect upon closing and reopening the web browser control/form. It does not appear to perform the validation in real-time making it impossible to make a dynamic solution. Hmmmmmm, this is less than ideal.

 

Control Source VS Navigate

Just a quick word of caution here.

Setting the Control Source via the control’s property sheet works very well, but I have found in VBA the Control Source property does not seem to work. So in VBA, my recommendation is to use the Navigate method. There’s also the added benefit that it does not appear to suffer from the character limit the control source does via VBA.
 

Expected URL Format & Behaviors

Before we explore how we can navigate to a URL/Website or local files, let’s briefly touch upon the expected format and issues at hand.

The most important thing to understand is the Web Browser control expects the protocol to be present. That means, you MUST include the:

https://
OR
http://

prefix with the supplied URL. Simply passing www.SomeWebsite.com will not work!

That said, if you are making a tool for users to make the manual entry of URLs, it truly isn’t hard to look at the first 3 characters to see if they are www and append the https:// automatically to make there user experience better. Realistically, I would have expected MS to do this behinds the scenes.

One other word of caution here however. There is one problem I have experience when using the http:// protocol. If we take my blog as an example, http://www.devhut.net, my site automatically switches all requests to be secured, so https://, this redirection thus cause the URL, since it isn’t the original requested URL to be open in Edge, rather than in the web browser control. This is far from an ideal user experience.

You can avoid this issue if you have implemented the Trusted Domain property, see Trusted Domains for more information on the subject.

Lastly, regarding using webpage links. Be forewarned that if the link uses target attribute to open in a new tab/window the URL will be open new pop-up window (still not sure what it is) without any ribbon, controls beyond close. This also makes for another very bad user experience.
 

Static/Hard Coded URLs

URLs

If you want to simply bind a Modern Web Browser control so it load a predetermined, static/hard coded, URL, then you can simply set its Control Source to:

="https://www.google.com"

Local Files

If on the other hand you wanted to bind to a static local file off of your hard drive then you’d set the control source to:

="https://msaccess/C:\Users\Dev\Desktop\myfile.html"

Read the section entitled Content From a Local File to learn more about handling local files.

 

URLs From A Table

Just like with the previous Web Browser control, in the most basic form, you could have a simple table with a field that stored the URL of various websites and then use the field as the Web Browser’s Control Source. That’s it, as you navigate between records, the Web Browser will automatically navigate to the URL.

So you set the table/query as the form’s Record Source and then you set the Web Browser control’s Control Source to the field that house the URLs.

Do note, that if you use a table to house ‘URL’ to local files, you must include the ‘https://msaccess/’ prefix as part of the ‘URL’ (file path and name) otherwise the local files will not render.
 

URLs From VBA

If on the other hand you want to programmatically navigate to a URL, then you can simply do:

Me.EdgeBrowser0.Navigate "https://www.google.com"

OR

Const sURL = "https://www.google.ca"
Me.EdgeBrowser0.Navigate sURL 

OR

Dim sURL                  As String

sURL = Me.URLControlName
Me.EdgeBrowser0.Navigate sURL

 

Content From a Local File

Now if you want to load a local file, things have changed!

Now you have to prefix the file path/name with the protocol “https://msaccess/“. Thus, to load a file, we do:

Me.EdgeBrowser0.Navigate "https://msaccess/C:\Users\Dev\Desktop\myfile.html"

We can thus load all sorts of types of local files, to name but a few:

• html files
• many types of images
• Text files, CSV files
• PDFs
• JSON/XML
• and many more

If you omit the protocol (https://msaccess/), the file will instead be opened directly in Edge, not the Access Web Browser control.

Also, if you make a typo in the path/filename, or the file does not exist, no error is reported back by the browser control. So you have no way of knowing there is an issue and things are not working properly. So be sure to use VBA code to test for the existance of the file you wish to navigate to before doing so!
 

Dynamic Content on the Fly

You can dynamically populate the web browser control quite easily, by doing something like:

    Dim sJS As String

    sJS = "document.open();" & _
          "document.write('<html><head></head><body><h1>Testing</h1></body></html>');" & _
          "document.close();"
    Debug.Print sJS
    Me.EdgeBrowser0.ExecuteJavascript sJS

if you pushing values from a form, then you probably need to remove line breaks (VbCrLf), so do something like:

    Dim sJS As String

    sJS = "document.open();" & _
          "document.write('<html><head></head><body>" & Replace(Me.YourHTMLControlName, vbCrLf, "") & "</body></html>');" & _
          "document.close();"
    Debug.Print sJS
    Me.EdgeBrowser0.ExecuteJavascript sJS

Note 1: This method does NOT report any errors back when it fails! So lots of fun troubleshooting when it doesn’t work properly.
Note 2: This does NOT work if you open an empty web browser control.

You need to load a page, any page, to have a ‘document’ instance you can work with. My solution thus far is to create a blank HTML file and load it when the form load to initialize the browser control document or first load the about:blank page, then the code works fine.

I’ve inquired with Microsoft on this issue and am waiting to hear back on the subject. (update 2024-01-24 – never heard back on the subject)

 

Opening a Blank Page

We seem to be in luck here, as it appears that if you don’t specify a Control Source or Navigate via VBA code, the control seems to, by default, load a blank page.
I take the above back as it appears to load a blank page, but it is not the about:blank page. Not sure what it is exactly!

That said, if you have a content displayed and wish to navigate to a blank page you simply do:

Me.EdgeBrowser0.Navigate "about:blank"

or you can also simply set the control’s Control Source to:

="about:blank"

 

Getting Browser Information

If ever you want to quickly validate the browser being emulated by the Modern Web Browser control, then simply set the control source to:

="https://www.whatsmybrowser.org/"

And as an example, as of the date of publishing this article, mine is reporting:

You’re using Edge 113.

 

Retrieving the Current Page’s URL

To retrieve the currently displayed URL, you can do so by simply:

Debug.Print Me.EdgeBrowser0.LocationURL

 

Retrieving the Current Page’s Title

Retrieving the web page’s title can be done by doing:

Debug.Print Me.EdgeBrowser0.RetrieveJavascriptValue("document.title")

 

Retrieving a Page’s HTML Source Code

We can retrieve the full source code (everything that would go between html tags) of a page by doing:

Debug.Print Me.EdgeBrowser0.RetrieveJavascriptValue("document.documentElement.innerHTML")

Or

Debug.Print Me.EdgeBrowser0.RetrieveJavascriptValue("document.getElementsByTagName('html')[0].innerHTML")

If you want to include the html tags then simply do:

Debug.Print Me.EdgeBrowser0.RetrieveJavascriptValue("document.getElementsByTagName('html')[0].outerHTML")

 

Saving a Page

Sadly, this isn’t possible.

That being said, you still have some options such as:

Saving Manually

To save the currently displayed webpage, simply:

1. Right-Click within the webpage.
2. In the context-menu, select Save as.
3. In the FileDialog window, select a location and give the File name of your choosing.
4. You may also change the Save as type to whatever format you desire.
5. Finally, click on the Save button.

Using Other Tools

You may wish to explore other tools for such purposes, such as:

HTTrack
Wget

to name but 2.
 

Refreshing the Webpage

Refreshing a page is equally easy and can be done by simply doing:

Me.EdgeBrowser0.Refresh

 

Executing Code on the Webpage

It is very simple to execute JavaScript code and can be done by doing something like:

Me.EdgeBrowser0.ExecuteJavascript "alert('Hello World!');"

You can also use this approach to run an existing JavaScript function. So say there was a function name mySquareRoot and we wanted to run it and retrieve it’s value, we could do something like:

Debug.Print Me.EdgeBrowser0.RetrieveJavascriptValue ("mySquareRoot()")

If the function took input variable(s), we can supply those as well (assuming it doesn’t come from the webpage itself), by doing:

Debug.Print Me.EdgeBrowser0.RetrieveJavascriptValue ("mySquareRoot(12)")

Working with the ExecuteJavascript method, it would appear the trailing Javascript ; is optional. Either way worked when I tested.
 

Managing Cookies

Because of the limited implementation of the WebView2 control in Microsoft Access’ Modern Web Browser control, sadly we do not have access to the WebView2 control’s cookie management class (https://learn.microsoft.com/en-us/dotnet/api/microsoft.web.webview2.core.corewebview2cookiemanager?view=webview2-dotnet-1.0.705.50). Like with most everything in the Modern Web Browser control, it must be done via JS!

So to delete cookies we can do something like:

    Dim sCmd As String
    
    sCmd = "document.cookie.replace(/(?<=^|;).+?(?=\=|;|$)/g, name => location.hostname.split('.').reverse().reduce(domain => (domain=domain.replace(/^\.?[^.]+/, ''),document.cookie=`${name}=;max-age=0;path=/;domain=${domain}`,domain), location.hostname));"
    Call Me.EdgeBrowser0.ExecuteJavascript(sCmd)

The issue being JS cannot delete HTTPOnly cookies, so the above is an incomplete solution.

Let’s just hope the Access Dev Team continues their work on this control and start to extend it with more of the WebView2 API commands/classes/… to truly empower Access!
 

Navigate To The Previous Page, Go Back

If ever you want to add the functionality to go back to the previous page the control was on, then you can simply do:

Me.EdgeBrowser0.ExecuteJavascript "history.back();"

 

Navigate To The Next Page, Go Forward

If you navigate back, as shown above, and wish to also offer the option to navigate forward again, then you can simply do:

Me.EdgeBrowser0.ExecuteJavascript "history.forward();"

 

Zooming In and Out of the Web Page

If you want to try an add some zoom functionality to your form/web browser control, you can do the following:

Add the following declaration to the form module head section:

Private lCurrZoomLvl As Integer

Then add the following to the web control’s On Document Complete event

Private Sub EdgeBrowser0_DocumentComplete(URL As Variant)
    lCurrZoomLvl = 100
End Sub

Finally, for the Zoom In button you would create an On Click event like:

Private Sub cmd_ZoomIn_Click()
    If lCurrZoomLvl < 500 Then
        lCurrZoomLvl = lCurrZoomLvl + 10
    End If
    Me.EdgeBrowser0.ExecuteJavascript "document.body.style.zoom = '" & lCurrZoomLvl & "%';"
End Sub

and for the Zoom Out button it would be:

Private Sub cmd_ZoomOut_Click()
    If lCurrZoomLvl > 10 Then
        lCurrZoomLvl = lCurrZoomLvl - 10
    End If
    Me.EdgeBrowser0.ExecuteJavascript "document.body.style.zoom = '" & lCurrZoomLvl & "%';"
End Sub

Obviously, adjust the control names according to what you’ve named your command buttons. Furthermore, as you can see by the command button code, I am doing jumps of 10%. Once again, you can change the jump size to whatever make you happy!
 

Stopping Links From Opening Popup Windows

As mentioned earlier, links that use the target attribute to open URLs in a new window or tab cause a pop-up to be generated outside of your calling form. If you want to avoid this behavior and want to keep everything in the browser control, then you can employ the Web Browser’s On Document Complete event to remove the attribute, as shown below:

Me.EdgeBrowser0.ExecuteJavascript "Array.from(document.querySelectorAll('a[target=""_blank""]')).forEach(link => link.removeAttribute('target'));"

 

Printing the Webpage

Sadly, because of the changes in the new browser control, we have lost some abilities on this front. We can no longer employ execCommand , nor ExecWB, but we can still use simple code to bring up the print dialog box.

To do so, we simply need to use the following line of code:

Me.EdgeBrowser0.ExecuteJavascript "window.print();"

 

Retrieving Information From The WebPage

Below is an example of how we can retrieve the value of an element:

Debug.Print Me.EdgeBrowser0.RetrieveJavascriptValue("document.getElementById('archives-dropdown-3').value")"

Here’s how we could retrieve the text of the 1st h2 heading entry:

Debug.Print Me.EdgeBrowser0.RetrieveJavascriptValue("document.getElementsByTagName('h2')[0].innerHTML")

More Advanced Data Extraction/Analysis

I thought I’d provide a simple example of a little more advance data extraction from the webpage displayed in the Modern Web Browser control. Below I show how you can extract, the headings, links and images from a page.

Dim oHTMLDoc              As MSHTML.htmlDocument
Dim i                     As Long
Dim j                     As Long
Dim iElementCounter       As Long

Set oHTMLDoc = New MSHTML.htmlDocument
oHTMLDoc.body.innerHTML = Me.EdgeBrowser0.RetrieveJavascriptValue("document.body.innerHTML")

'Extract Heading Elements
For j = 1 To 5 'h1 to h5
    For i = 0 To oHTMLDoc.getElementsByTagName("h" & j).length - 1
        Debug.Print iElementCounter + 1, "h" & j, oHTMLDoc.getElementsByTagName("h" & j)(i).innerHTML
        iElementCounter = iElementCounter + 1
    Next
Next j

Debug.Print 'Blank line

'Extract all the links from the page
For i = 0 To oHTMLDoc.getElementsByTagName("a").length - 1
    Debug.Print i + 1, oHTMLDoc.getElementsByTagName("a")(i).href
Next

Debug.Print 'Blank line

'Extract all the images from the page
For i = 0 To oHTMLDoc.getElementsByTagName("img").length - 1
    Debug.Print i + 1, oHTMLDoc.getElementsByTagName("img")(i).src
Next

If you’re looking for more information regarding advanced automation/parsing/analysis of a web page, then look at my article:

 

Retrieving the Current Page’s Meta Values

Sadly, we cannot play around with header information as easily as we used to with the old Web Browser control (I’m still exploring though).

That said, if you want a specific element, it is still pretty straightforward to accomplish if you are familiar with JavaScript. Here’s an example of how you can retrieve the page’s description meta tag value, assuming it has such a tag.

Debug.Print Me.EdgeBrowser0.RetrieveJavascriptValue("document.querySelector('meta[name=""description""]').content")

Similarily, you can also get:

Debug.Print Me.EdgeBrowser0.RetrieveJavascriptValue("document.querySelector('meta[name=""keywords""]').content")

Debug.Print Me.EdgeBrowser0.RetrieveJavascriptValue("document.querySelector('meta[name=""viewport""]').content")

Debug.Print Me.EdgeBrowser0.RetrieveJavascriptValue("document.querySelector('meta[name=""robots""]').content")

Debug.Print Me.EdgeBrowser0.RetrieveJavascriptValue("document.querySelector('meta[name=""generator""]').content")

etc…

now, because of the fact that meta tags are not always present, and to avoid errors, we should probably change the above to something more like (and yes, there are other ways we could approach this):

If Me.EdgeBrowser0.RetrieveJavascriptValue("document.querySelector('meta[name=""description""]')") <> "null" Then
    Debug.Print Me.EdgeBrowser0.RetrieveJavascriptValue("document.querySelector('meta[name=""description""]').content")
Else
    Debug.Print "Description Meta tag not present."
End If

If you wanted to enumerate all the meta tags to do some other analysis, here one example to get you started (and obviously you can apply the same concept to other header elements).

Dim lMetaTags As Long
Dim i As Long
lMetaTags = Me.EdgeBrowser0.RetrieveJavascriptValue("document.getElementsByTagName('meta').length")
If lMetaTags > 0 Then
    For i = 0 To lMetaTags - 1
        Debug.Print Me.EdgeBrowser0.RetrieveJavascriptValue("document.getElementsByTagName('meta')[" & i & "].outerHTML")
    Next i
End If

 

Navigating The File System

In the previous version of the Web Browser control, it was possible to set the control source to a path and use the browser as an interactive tool to navigate the file system. Sadly, it would appear that currently this is not supported by the Modern Web Browser control.

This has now been confirmed by the Access Dev Team as no longer possible with the new Web Browser control.
 

Modern Web Browser Control Bugs

Sadly, this new control, the Modern Web Browser control, is plagued with issues! It obviously was not, is not, truly ready for production use! A sad statement for the level of quality that the Microsoft Access Dev Team feels is acceptable to release to their users.

FYI, the best way to report bugs and also provide feedback is to use the Feedback portal, for all the good it will do (history speaks volumes as to why I make that comment!). I’ve started to make a number of feedback entries about the new control and I’d urge to up vote them, and/or create new feedback entries of your own in the hopes that Microsoft may address, some of them, eventually.

The main Access Feedback portal can be accessed at:

and my feedback (and others), thus far, includes (non-exhaustive listing!):

 
Even more! Search this blog for even more Microsoft Accesss Modern Web Browser control bugs as they are not all listed here and I haven’t created feedback items for all of the issues.
 

Q & A

Just to answer a few questions I’ve seen posted in forums.

 

Demo Database

Feel free to download a 100% unlocked copy of a sample database I have put together to illustrate some of what is discussed above by using the link provided below:

Download “Playing With The Modern Web Browser Control” PlayingWithTheModernWebBrowserControl_v1.000.zip – Downloaded 9495 times – 114.68 KB  

Notice About Content/Downloads/Demos

Disclaimer/Notes:

If you do not have Microsoft Access, simply download and install the freely available runtime version (this permits running MS Access databases, but not modifying their design):

Microsoft Access 2010 Runtime
Microsoft Access 2013 Runtime
Microsoft Access 2016 Runtime
Microsoft 365 Access Runtime

 

Additional Articles/Demos

Here are a few of my other article that touch upon the New Modern Web Browser control that may also be of interest:

 

Additional Resources

I’ve found Googling the subject to be pretty much useless and nearly impossible to find Microsoft’s documentation, so I thought I’d provide the links myself and save you all the frustration. This is even more important at the time of writing the article as using F1 in the designer or VBA does not redirect properly (yes, this too has been reported to the Access Dev Team).

 
 

Acknowledgements

I just want to take a moment to thank Joe Jimenez of the Microsoft Access Dev Team for his ongoing support. I have bombarded him with e-mails with questions and reporting bugs and he is always been most helpful. He also alerted me to recent updates that resolve issues, so as to be in a position to report them here as well.
 

Page History

Date	Summary of Changes
2023-05-21	Initial Release
2023-05-22	Added the Improvements section to the article. Added the Limitations section to the article. Added the Static/Hard Coded URLs section to the article. Added the Retrieving a Page’s HTML Source Code section to the article. Added the Executing Code on the Webpage section to the article. Added the Printing the Webpage section to the article. Added the Retrieving Information From The Webpage section to the article. Added the Retrieving the Current Page’s Meta Values section to the article. Added the Navigating The File System section to the article. Added the Resources section to the article.
2023-05-23	Added the Control Source VS Navigate section to the article. Added the Getting Browser Information section to the article.
2023-05-24	Added the Compatibility With Older Access Versions section to the article. Added the Expected URL Format & Behaviors section to the article. Added the Stopping Links From Opening External Tabs & Windows section to the article. Added the Demo Database section to the article.
2023-05-25	Added the Q & A section to the article.
2023-05-31	Added the Navigate To The Previous Page, Go Back section to the article. Added the Navigate To The Next Page, Go Forward section to the article. Added the Zooming In and Out of the Web Page section to the article.
2023-06-01	Added the Modern Web Browser Control Bugs section to the article. Added the Acknowledgements section to the article.
2023-06-02	Added the YouTube video.
2023-06-06	Added the Additional Articles/Demos section to the article.
2023-06-08	Added the Dynamic Content on the Fly section to the article.
2023-06-10	Added the Overview section to the article.
2024-05-12	Added the Saving a Page section to the article.