Overview of WebView2 features and APIs
Embedding the WebView2 control in your app gives your app access to various methods and properties that are provided through the WebView2 classes or interfaces. WebView2 has hundreds of APIs that provide a vast set of capabilities, ranging from enhancing your app's native-platform capabilities, to enabling your app to modify browser experiences. This article provides a high-level grouping of the WebView2 APIs to help you understand the different things you can do using WebView2.
Overview of top-level feature areas
When hosting the WebView2 control, your app has access to the following features and APIs:
Feature area | Purpose |
---|---|
Main classes: Environment, Controller, and Core | The CoreWebView2Environment , CoreWebView2Controller , and CoreWebView2 classes (or equivalent interfaces) work together so your app can host a WebView2 browser control and access its browser features. These large classes expose a wide range of APIs that your host app can access to provide the below categories of browser-related features for your users. |
Web/native interop | Embed web content into native applications. Communicate between native code and web code using simple messages, JavaScript code, and native objects. |
Browser features | The WebView2 control gives your app access to many browser features. You can modify these browser features and turn them on or off. |
Process management | Get information about running WebView2 processes, exiting processes, and failed processes, so your app can take action accordingly. |
Navigate to pages and manage loaded content | Manage navigation to webpages and manage content that's loaded in the webpages. |
iframes | Embed other webpages into your own webpage. Detect when embedded webpages are created, detect when embedded webpages are navigating, and optionally bypass x-frame options. |
Authentication | Your app can handle basic authentication using the WebView2 control. Basic authentication is a specific authentication approach that's part of the HTTP protocol. |
Rendering WebView2 in non-framework apps | Use these APIs to set up the WebView2 rendering system if your host app doesn't use a UI framework. This rendering setup controls how WebView2 renders output into your host app, and how WebView2 handles input, focus, and accessibility. |
Rendering WebView2 using Composition | For composition-based WebView2 rendering, use CoreWebView2Environment to create a CoreWebView2CompositionController . CoreWebView2CompositionController provides the same APIs as CoreWebView2Controller , but also includes APIs for composition-based rendering. |
Environment options | User data: Manage the user data folder (UDF), which is a folder on the user's machine. The UDF contains data related to the host app and WebView2. WebView2 apps use user data folders to store browser data, such as cookies, permissions, and cached resources. Manage multiple profiles under a single UDF. Runtime selection supports prerelease testing and self-hosting. You can specify a search order for browser preview channels, and specify which browser preview channels are searched for. |
Performance and debugging | Analyze and debug performance, handle performance-related events, and manage memory usage to increase the responsiveness of your app. |
Chrome DevTools Protocol (CDP) | Instrument, inspect, debug, and profile Chromium-based browsers. The Chrome DevTools Protocol (CDP) is the foundation for the Microsoft Edge DevTools. Use the Chrome DevTools Protocol for features that aren't implemented in the WebView2 platform. |
This page only lists APIs that are in Release SDKs; it doesn't list Experimental APIs, or Stable APIs that are not yet available in Release SDKs. For a comprehensive list of APIs including Experimental APIs, see Release Notes for the WebView2 SDK.
Main classes: Environment, Controller, and Core
The CoreWebView2Environment
, CoreWebView2Controller
, and CoreWebView2
classes (or equivalent interfaces) work together so your app can host a WebView2 browser control and access its browser features. These three large classes expose a wide range of APIs that your host app can access to provide many categories of browser-related features for your users.
- The
CoreWebView2Environment
class represents a group of WebView2 controls that share the same WebView2 browser process, user data folder, and renderer processes. From thisCoreWebView2Environment
class, you create pairs ofCoreWebView2Controller
andCoreWebView2
instances. - The
CoreWebView2Controller
class is responsible for hosting-related functionality such as window focus, visibility, size, and input, where your app hosts the WebView2 control. - The
CoreWebView2
class is for the web-specific parts of the WebView2 control, including networking, navigation, script, and parsing and rendering HTML.
See also:
Web/native interop
The Microsoft Edge WebView2 control lets you embed web content into native applications. You can communicate between native code and web code using simple messages, JavaScript code, and native objects. The following are the main APIs for communicating between web and native code.
Subsections below:
Common use cases for web/native interop:
- Update the native host window title after navigating to a different website.
- Send a native camera object and use its methods from a web app.
- Run a dedicated JavaScript file on the web side of an application.
See also:
- Interop of native-side and web-side code
- Call web-side code from native-side code
- Call native-side code from web-side code
- Call native-side WinRT code from web-side code
- JavaScript APIs in WebView2 for
window.chrome.webview
JavaScript APIs
Host/web object sharing
WebView2 enables objects that are defined in native code to be passed to your app's web-side code. Host objects are any objects that are defined in native code that you choose to pass to your app's web-side code.
Host objects can be projected into JavaScript, so that you can call native object methods (or other APIs) from your app's web-side code. For example, your app can call such APIs as a result of user interaction on the web side of your app. This way, you don't need to reimplement your native objects' APIs, such as methods or properties, in your web-side code.
CoreWebView2
Class:CoreWebView2Settings
Class:
Script execution
Allows the host app to add JavaScript code in the web content within the WebView2 control.
CoreWebView2
Class:- CoreWebView2ExecuteScriptResult Class
CoreWebView2Frame
Class:- CoreWebView2ScriptException Class
CoreWebView2Settings
Class:
Web messaging
Your app can send messages to the web content that's within the WebView2 control, and receive messages from that web content. Messages are sent as strings or JSON objects.
You can optionally post and receive DOM objects along with your message, via the additionalObjects
parameter of PostWebMessageAsJson
(.NET, WinRT) or via PostWebMessageAsJsonWithAdditionalObjects
(Win32). The WebView2 CoreWebView2FileSystemHandle
class represents the DOM FileSystemHandle
, and CoreWebView2File
represents the DOM File
. See also chrome.webview.postMessageWithAdditionalObjects
in the JavaScript Reference.
CoreWebView2
Class:CoreWebView2Frame
Class:CoreWebView2Settings
Class:CoreWebView2Environment
Class:CoreWebView2FileSystemHandle
Class:CoreWebView2FileSystemHandleKind Enum
File
Directory
CoreWebView2FileSystemHandlePermission Enum
ReadOnly
ReadWrite
Script dialogs
When hosting WebView2, your app can manage different JavaScript dialogs, to suppress them or to replace them with custom dialogs.
CoreWebView2
Class:- CoreWebView2ScriptDialogOpeningEventArgs Class
Shared buffer
The SharedBuffer API supports sharing buffers between the WebView2 host app process and WebView2 renderer process, based on shared memory from the OS.
CoreWebView2
Class:CoreWebView2Environment
Class:CoreWebView2Frame
Class:- CoreWebView2SharedBuffer Class
- CoreWebView2SharedBufferAccess Enum
ReadOnly
ReadWrite
Browser features
The WebView2 control gives your app access to many browser features. You can modify these browser features and turn them on or off.
Subsections below:
- Printing
- Cookies
- Image capture
- Downloads
- Permissions
- Context menus
- Status bar
- Fluent overlay scrollbars
- User Agent
- Autofill
- Audio
- Hit-testing of mouse-clicks in regions
- Swipe gesture navigation
- Enable or disable the browser responding to accelerator keys (shortcut keys)
- Fullscreen
- PDF toolbar
- Theming
- Language
- New window
- Close window
- Document title
- Favicon
- Security and privacy
Printing
You can print a webpage to a printer, PDF file, or PDF stream by configuring custom print settings.
See also:
CoreWebView2
Class:CoreWebView2Environment
Class:- CoreWebView2PrintSettings Class
- CoreWebView2PrintDialogKind Enum
- CoreWebView2PrintStatus Enum
Cookies
You can use cookies in WebView2 to manage user sessions, store user personalization preferences, and track user behavior.
See also:
CoreWebView2
Class:- CoreWebView2Cookie Class
- CoreWebView2CookieManager Class
CoreWebView2Profile
Class:
Image capture
By hosting WebView2, your app can capture screenshots and indicate which format to use to save the image.
CoreWebView2
Class:
Downloads
Your app can manage the download experience in WebView2. Your app can:
- Allow or block downloads based on different metadata.
- Change the download location.
- Configure a custom download UI.
- Customize the default UI.
General:
CoreWebView2
Class:
Modify Default Experience:
CoreWebView2
Class:CoreWebView2Profile
Class:
Custom Download Experience:
Permissions
Different webpages may ask you for permissions to access some privileged resources, such as geolocation sensor, camera, and microphone. Your host app can programmatically respond to permissions requests and can replace the default permissions UI with its own UI.
CoreWebView2
Class:CoreWebView2Frame
Class:- CoreWebView2PermissionKind Enum
CoreWebView2PermissionRequestedEventArgs
Class:- CoreWebView2PermissionSetting Class
CoreWebView2Profile
Class:
Context menus
The WebView2 control provides a default context menu (right-click menu) which you can customize or disable, and you can also create your own context menu.
See also:
CoreWebView2
Class:- CoreWebView2ContextMenuItem Class
- CoreWebView2ContextMenuRequestedEventArgs Class
- CoreWebView2ContextMenuTarget Class
CoreWebView2Environment
Class:CoreWebView2Settings
Class:
Status bar
A status bar is located in the bottom left of the page and displays the state of the webpage being displayed. In WebView2 you can enable/disable the status bar, get the text in the status bar, and find out when the status bar text has changed.
CoreWebView2
Class:CoreWebView2Settings
Class:
Fluent overlay scrollbars
Stylizes scrollbars with Microsoft Fluent design and makes the scrollbars overlay over the web content. This adaptive scrollbar design adjusts to various devices and window sizes.
To experiment with Fluent overlay scrollbars, in Microsoft Edge, go to edge://flags
and then enter Fluent overlay scrollbars.
See also:
- WebView2 browser flags -
msEdgeFluentOverlayScrollbar
andmsOverlayScrollbarWinStyle
flags.
CoreWebView2EnvironmentOptions
Class:CoreWebView2ScrollbarStyle Enum
Default
FluentOverlay
User Agent
The user agent is a string that represents the identity of the program on behalf of the user, such as the browser name. In WebView2, you can set the user agent.
See also:
CoreWebView2Settings
Class:
Autofill
Your app can independently control whether the browser's autofill functionality is enabled for general information or for passwords.
CoreWebView2Settings
Class:
Audio
Your app can mute and unmute all audio, and find out when audio is playing.
Hit-testing of mouse-clicks in regions
Provides hit-testing results on the regions that a WebView2 contains. Useful for visually hosted applications that want to handle mouse events on the non-client area of the WebView2 window.
CoreWebView2CompositionController
Class:CoreWebView2NonClientRegionChangedEventArgs
Class:CoreWebView2NonClientRegionKind Enum
Caption
Client
Nowhere
CoreWebView2Settings
Class:
Swipe gesture navigation
By hosting the WebView2 control, your app can enable or disable swiping gesture navigation on touch input-enabled devices. This gesture allows end users to:
- Swipe left/right (swipe horizontally) to navigate to the previous or next page in the navigation history.
- Pull to refresh (swipe vertically) the current page.
This feature is currently disabled by default in the browser. To enable this feature in WebView2, set the AdditionalBrowserArguments
property, specifying the --pull-to-refresh
switch.
CoreWebView2Settings
Class:CoreWebView2EnvironmentOptions
Class:
Enable or disable the browser responding to accelerator keys (shortcut keys)
ICoreWebView2AcceleratorKeyPressedEventArgs
has a IsBrowserAcceleratorKeyEnabled
property to allow you to control whether the browser handles accelerator keys (shortcut keys), such as Ctrl+P or F3.
See also:
- Keyboard accelerators, below.
CoreWebView2AcceleratorKeyPressedEventArgs
Class:
Fullscreen
In WebView2, you can find out when an HTML element enters or leaves full-screen view.
PDF toolbar
In the browser PDF viewer, there's a PDF-specific toolbar along the top. In WebView2, you can hide some of the items in the PDF viewer toolbar.
CoreWebView2Settings
Class:
Theming
In WebView2, you can customize the color theme as system, light, or dark.
CoreWebView2Profile
Class:
Language
The Language
property sets the default display language for WebView2 that applies to the browser UI (such as context menus and dialogs), along with setting the accept-language
HTTP header which WebView2 sends to websites.
The ScriptLocale
property allows the host app to set the default locale for all Intl
JavaScript APIs and other JavaScript APIs that depend on it, such as Intl.DateTimeFormat()
, which affects string formatting in time/date formats.
CoreWebView2EnvironmentOptions
Class:CoreWebView2ControllerOptions
Class:
New window
WebView2 provides functionality to handle the JavaScript function window.open()
.
Close window
WebView2 provides functionality to handle the JavaScript function window.close()
.
CoreWebView2
Class:CoreWebView2Controller
Class:
Document title
Your app can detect when the title of the current top-level document has changed.
CoreWebView2
Class:
Favicon
In WebView2, you can set a Favicon for a website, or get notified when it changes.
CoreWebView2
Class:
Security and privacy
Tracking prevention
Tracking prevention enables the host app to control the level of tracking prevention of the WebView2 control that's associated with the user profile.
CoreWebView2EnvironmentOptions
Class:CoreWebView2Profile
Class:- CoreWebView2TrackingPreventionLevel Enum
None
Basic
Balanced
Strict
SmartScreen
Microsoft Defender SmartScreen ("SmartScreen") is enabled by default. The IsReputationCheckingRequired
property controls whether SmartScreen is enabled.
If you don't disable SmartScreen, you must provide notice to all users that your software includes Microsoft Defender SmartScreen, and collects and sends the user's information to Microsoft as disclosed in Microsoft Privacy Statement and in SmartScreen in Microsoft Edge Privacy Whitepaper.
See also:
- SmartScreen in Data and privacy in WebView2.
CoreWebView2Settings
Class:
Custom crash reporting
If any WebView2 process crashes, one or more minidump files are created and sent to Microsoft for diagnosis. Use this API to customize crash reporting when running diagnostics and doing analysis.
- To prevent crash dumps from being sent to Microsoft, set the
IsCustomCrashReportingEnabled
property tofalse
. - To locate crash dumps and do customization with them, use the
CrashDumpFolderPath
property.
See also:
- Custom crash reporting in Data and privacy in WebView2.
- Minidump Files
CoreWebView2EnvironmentOptions
Class:CoreWebView2Environment
Class:
Browser extensions
Your app can embed a WebView2 control that uses browser extensions (add-ons). A Microsoft Edge extension is a small app that developers use to add or modify features of Microsoft Edge to improve a user's browsing experience.
See also:
CoreWebView2EnvironmentOptions
Class:CoreWebView2Profile
Class:
Process management
Get information about running WebView2 processes, exiting processes, and failed processes, so that your app can take action accordingly.
Subsections below:
CoreWebView2
Class:- CoreWebView2BrowserProcessExitedEventArgs Class
CoreWebView2Environment
Class:- CoreWebView2ProcessFailedEventArgs Class
- CoreWebView2ProcessFailedKind Enum
- CoreWebView2ProcessFailedReason Enum
- CoreWebView2ProcessInfo Class
Frame process info
The Frame Process Info API, including GetProcessExtendedInfos
, provides a snapshot collection of all frames that are actively running in the associated renderer process. This API enables your app to detect which part of WebView2 is consuming resources such as memory or CPU usage.
CoreWebView2Environment
Class:CoreWebView2ProcessExtendedInfo
Class:CoreWebView2
Class:CoreWebView2Frame
Class:CoreWebView2FrameInfo
Class:
Navigate to pages and manage loaded content
Through the WebView2 control, your app can manage navigation to webpages and manage content that's loaded in the webpages.
Subsections below:
- Manage content loaded into WebView2
- Navigation history
- Navigation kind
- Block unwanted navigating
- Navigation events
- Manage network requests in WebView2
- Custom scheme registration
- Client certificates
- Server certificates
- Launch an external URI scheme
Manage content loaded into WebView2
These APIs load, stop loading, and reload content to WebView2. The content that's loaded can be:
- Content from a URL.
- A string of HTML.
- Local content via virtual host name to local folder mapping.
- Content from a constructed network request.
See also:
CoreWebView2
Class:- CoreWebView2.ClearVirtualHostNameToFolderMapping Method
- CoreWebView2.Navigate Method
- CoreWebView2.NavigateToString Method
- CoreWebView2.NavigateWithWebResourceRequest Method
- CoreWebView2.Reload Method
- CoreWebView2.SetVirtualHostNameToFolderMapping Method
- CoreWebView2.Stop Method
- CoreWebView2.WebResourceRequested Event
CoreWebView2Settings
Class:
Navigation history
The history methods allow back and forward navigation in WebView2, and the history events provide information about the changes in history and in WebView2's current source.
Navigation kind
NavigationKind
gets the navigation kind of each navigation, such as Back/Forward, Reload, or navigation to a new document.
CoreWebView2NavigationStartingEventArgs
Class:- CoreWebView2NavigationKind Enum
Block unwanted navigating
The NavigationStarting
event allows the app to cancel navigating to specified URLs in WebView2, including for frames.
CoreWebView2
Class:- CoreWebView2.NavigationStarting Event
- CoreWebView2.FrameNavigationStarting Event - superseded; use
CoreWebView2Frame.NavigationStarting
instead
CoreWebView2Frame
Class:- CoreWebView2NavigationStartingEventArgs Class
Navigation events
With NavigationStarting
and the other navigation events, the app can be informed of the state of navigation in WebView2. A navigation is the process for loading a new URL.
See also:
CoreWebView2
Class:- CoreWebView2.ContentLoading Event
- CoreWebView2.DOMContentLoaded Event
- CoreWebView2.FrameNavigationCompleted Event - superseded; use
CoreWebView2Frame.NavigationCompleted
instead. - CoreWebView2.NavigationCompleted Event
- CoreWebView2ContentLoadingEventArgs Class
- CoreWebView2DOMContentLoadedEventArgs Class
CoreWebView2Frame
Class:- CoreWebView2NavigationCompletedEventArgs Class
Manage network requests in WebView2
The WebResourceRequested
event allows the app to intercept and override all network requests in WebView2. The WebResourceResponseReceived
event allows the app to monitor the request sent to and the response received from the network.
See also:
CoreWebView2
Class:
Custom scheme registration
The CustomSchemeRegistration
allows registration of custom schemes in WebView2 so that the app can handle the WebResourceRequested
event for requests to those custom scheme URLs and navigate the WebView2 to such URLs.
- CoreWebView2CustomSchemeRegistration Class
CoreWebView2EnvironmentOptions
Class:
Client certificates
In WebView2, you can use the Client Certificate API to select the client certificate at the application level. This API allows you to:
- Display a UI to the user, if desired.
- Replace the default client certificate dialog prompt.
- Programmatically query the certificates.
- Select a certificate from the list to respond to the server, when WebView2 is making a request to an HTTP server that needs a client certificate for HTTP authentication.
Server certificates
In WebView2, you can use the Server Certificate API to trust the server's TLS certificate at the application level. This way, your host app can render the page without prompting the user about the TLS error, or your host app can automatically cancel the request.
Launch an external URI scheme
Launch a URI scheme that is registered with the OS.
CoreWebView2
Class:- CoreWebView2LaunchingExternalUriSchemeEventArgs Class
- CoreWebView2LaunchingExternalUriSchemeEventArgs.Cancel Property
- CoreWebView2LaunchingExternalUriSchemeEventArgs.InitiatingOrigin Property
- CoreWebView2LaunchingExternalUriSchemeEventArgs.IsUserInitiated Property
- CoreWebView2LaunchingExternalUriSchemeEventArgs.Uri Property
- CoreWebView2LaunchingExternalUriSchemeEventArgs.GetDeferral Method
iframes
iframes allow you to embed other webpages into your own webpage. In WebView2, you can:
- Find out when iframes are created.
- Find out when iframes are navigating.
- Allow bypassing x-frame options.
See also:
Authentication
Your app can handle basic authentication using the WebView2 control. Basic authentication is a specific authentication approach that's part of the HTTP protocol.
See also:
Rendering WebView2 in non-framework apps
Use these APIs to set up the WebView2 rendering system if your host app doesn't use a UI framework. This rendering setup controls how WebView2 renders output into your host app, and how WebView2 handles input, focus, and accessibility.
When to use these APIs
UI framework - If you're using a UI framework for your app, you should use the WebView2 element that's provided by that UI framework, rather than using these APIs.
No UI framework, and not using Composition - If you're not using a UI framework for your app (for example, if you're using pure Win32 directly), or if your UI framework doesn't have a WebView2 element, then you need to create
CoreWebView2Controller
and render it into your app, using these APIs in this section.No UI framework, and using Composition - If your app UI is built using DirectComposition or Windows.UI.Composition, you should use
CoreWebView2CompositionController
rather than using these APIs; see Rendering WebView2 using Composition, below.
Subsections below:
- Sizing, positioning, and visibility
- Zooming
- Rasterization scale
- Focus and tabbing
- Parent window
- Keyboard accelerators
- Default background color
CoreWebView2Controller
Class:CoreWebView2Environment
Class:
Sizing, positioning, and visibility
CoreWebView2Controller
takes a parent HWND
. The Bounds
property sizes and positions the WebView2 relative to the parent HWND
. The visibility of WebView2 can be toggled using IsVisible
.
CoreWebView2Controller
Class:
Zooming
WebView2 ZoomFactor
is used to scale just the web content of the window. UI scaling is also updated when the user zooms the content by pressing Ctrl while rotating the mouse wheel.
CoreWebView2Controller
Class:CoreWebView2Settings
Class:
Rasterization scale
The RasterizationScale API scales all WebView2 UI including context menus, tooltip, and popups. The app can set whether the WebView2 should detect monitor scale changes and automatically update the RasterizationScale. BoundsMode
is used to configure whether the Bounds property is interpreted as raw pixels, or DIPs (which need to be scaled by RasterizationScale
).
Focus and tabbing
The WebView2 control raises events to let the app know when the control gains focus or loses focus. For tabbing (pressing the Tab key), there's an API to move focus into WebView2 and an event for WebView2 to request the app to take focus back.
Parent window
WebView2 can be reparented to a different parent window handle (HWND
). WebView2 also needs to be notified when the app's position on the screen has changed.
CoreWebview2Controller
Class:
Keyboard accelerators
When WebView2 has focus, it directly receives input from the user. An app may want to intercept and handle certain accelerator key combinations (shortcut keys), or disable the normal browser accelerator key behaviors.
See also Enable or disable the browser responding to accelerator keys (shortcut keys), above.
- CoreWebView2AcceleratorKeyPressedEventArgs Class
CoreWebView2Controller
Class:CoreWebView2Settings
Class:
Default background color
WebView2 can specify a default background color. The color can be any opaque color, or transparent. This color will be used if the HTML page doesn't set its own background color.
CoreWebView2Controller
Class:
Rendering WebView2 using Composition
For composition-based WebView2 rendering, use CoreWebView2Environment
to create a CoreWebView2CompositionController
. CoreWebView2CompositionController
provides the same APIs as CoreWebView2Controller
, but also includes APIs for composition-based rendering.
Subsections below:
- CoreWebView2CompositionController Class
CoreWebView2Environment
Class:
Connecting to the visual tree
WebView2 can connect its composition tree to an IDCompositionVisual, IDCompositionTarget, or Windows::UI::Composition::ContainerVisual
.
CoreWebView2CompositionController
Class:
Forwarding input
Spatial input (mouse, touch, pen) is received by the application and must be sent to WebView2. WebView2 notifies the app when the cursor should be updated based on the mouse position.
CoreWebView2CompositionController
Class:CoreWebView2Environment
Class:- CoreWebView2PointerInfo Class
Drag and drop
Dragging from a WebView2 control to another application is supported by default. However, dragging to a WebView2 control requires that when the host app receives an IDropTarget
event from the system, the host app must forward the event to the WebView2 control. Dragging to a WebView2 control includes drag-and-drop operations that are entirely within a WebView2 control.
Use the following APIs to forward IDropTarget
events from the system to the WebView2 control.
CoreWebView2CompositionController
Class:
Accessibility
By default, WebView2 will show up in the accessibility tree as a child of the parent HWND, for Win32/C++ apps. WebView2 provides API to better position the WebView2 content relative to other elements in the application.
Environment options
Subsections below:
User data
Manage the user data folder (UDF), which is a folder on the user's machine. The UDF contains data related to the host app and WebView2. WebView2 apps use user data folders to store browser data, such as cookies, permissions, and cached resources.
Subsections below:
See also:
CoreWebView2Environment
Class:CoreWebView2EnvironmentOptions
Class:
Clearing browsing data:
CoreWebView2Profile
Class:- CoreWebView2BrowsingDataKinds Enum
Multiple profiles
Manage multiple profiles under a single user data folder.
See also:
Create an options object that defines a profile:
CoreWebView2Environment
Class:- CoreWebView2ControllerOptions Class
Create a WebView2 control that uses the profile:
CoreWebView2Environment
Class:
Access and manipulate the profile:
CoreWebView2
Class:- CoreWebView2Profile Class
Delete a profile
Your app can delete user profiles for a WebView2 web browser control.
See also:
CoreWebView2Profile
Class:
Runtime selection
Runtime selection supports prerelease testing and self-hosting. When creating a WebView2 environment:
- To specify a search order for browser preview channels, use the
CoreWebView2EnvironmentOptions.ChannelSearchKind
property. - To specify which browser preview channels are searched for, use the
CoreWebView2EnvironmentOptions.ReleaseChannels
property.
See also:
- Test upcoming APIs and features
- Prerelease testing using preview channels
- Self-host by deploying preview channels
CoreWebView2EnvironmentOptions
Class:CoreWebView2ChannelSearchKind Enum
MostStable
LeastStable
CoreWebView2ReleaseChannels Enum
None
Stable
Beta
Dev
Canary
Performance and debugging
Analyze and debug performance, handle performance-related events, and manage memory usage to increase the responsiveness of your app.
Subsections below:
Memory usage target
Specifies memory consumption levels, such as low
or normal
.
CoreWebView2
Class:- CoreWebView2MemoryUsageTargetLevel Enum
Chrome DevTools Protocol (CDP)
The Chrome DevTools Protocol (CDP) provides APIs to instrument, inspect, debug, and profile Chromium-based browsers. The Chrome DevTools Protocol is the foundation for the Microsoft Edge DevTools. Use the Chrome DevTools Protocol for features that aren't implemented in the WebView2 platform.
See also:
Open:
CoreWebView2Settings
Class:CoreWebView2
Class:
Call:
CoreWebView2
Class:
Receiver:
See also
- Introduction to Microsoft Edge WebView2
- WebView2 API Reference - API Reference links for additional platforms and languages, such as WinRT/C++ (COM).