Electron Documentation1.7.8

Docs / API / webContents


Render and control web pages.

Process: Main

webContents is an EventEmitter. It is responsible for rendering and controlling a web page and is a property of the BrowserWindow object. An example of accessing the webContents object:

const {BrowserWindow} = require('electron')

let win = new BrowserWindow({width: 800, height: 1500})

let contents = win.webContents


These methods can be accessed from the webContents module:

const {webContents} = require('electron')


Returns WebContents[] - An array of all WebContents instances. This will contain web contents for all windows, webviews, opened devtools, and devtools extension background pages.


Returns WebContents - The web contents that is focused in this application, otherwise returns null.


Returns WebContents - A WebContents instance with the given ID.

Class: WebContents

Render and control the contents of a BrowserWindow instance.

Process: Main

Instance Events

Event: ‘did-finish-load’

Emitted when the navigation is done, i.e. the spinner of the tab has stopped spinning, and the onload event was dispatched.

Event: ‘did-fail-load’


This event is like did-finish-load but emitted when the load failed or was cancelled, e.g. window.stop() is invoked. The full list of error codes and their meaning is available here.

Event: ‘did-frame-finish-load’


Emitted when a frame has done navigation.

Event: ‘did-start-loading’

Corresponds to the points in time when the spinner of the tab started spinning.

Event: ‘did-stop-loading’

Corresponds to the points in time when the spinner of the tab stopped spinning.

Event: ‘did-get-response-details’


Emitted when details regarding a requested resource are available. status indicates the socket connection to download the resource.

Event: ‘did-get-redirect-request’


Emitted when a redirect is received while requesting a resource.

Event: ‘dom-ready’


Emitted when the document in the given frame is loaded.

Event: ‘page-favicon-updated’


Emitted when page receives favicon urls.

Event: ‘new-window’


Emitted when the page requests to open a new window for a url. It could be requested by window.open or an external link like <a target='_blank'>.

By default a new BrowserWindow will be created for the url.

Calling event.preventDefault() will prevent Electron from automatically creating a new BrowserWindow. If you call event.preventDefault() and manually create a new BrowserWindow then you must set event.newGuest to reference the new BrowserWindow instance, failing to do so may result in unexpected behavior. For example:

myBrowserWindow.webContents.on('new-window', (event, url) => {
  const win = new BrowserWindow({show: false})
  win.once('ready-to-show', () => win.show())
  event.newGuest = win

Event: ‘will-navigate’


Emitted when a user or the page wants to start navigation. It can happen when the window.location object is changed or a user clicks a link in the page.

This event will not emit when the navigation is started programmatically with APIs like webContents.loadURL and webContents.back.

It is also not emitted for in-page navigations, such as clicking anchor links or updating the window.location.hash. Use did-navigate-in-page event for this purpose.

Calling event.preventDefault() will prevent the navigation.

Event: ‘did-navigate’


Emitted when a navigation is done.

This event is not emitted for in-page navigations, such as clicking anchor links or updating the window.location.hash. Use did-navigate-in-page event for this purpose.

Event: ‘did-navigate-in-page’


Emitted when an in-page navigation happened.

When in-page navigation happens, the page URL changes but does not cause navigation outside of the page. Examples of this occurring are when anchor links are clicked or when the DOM hashchange event is triggered.

Event: ‘will-prevent-unload’


Emitted when a beforeunload event handler is attempting to cancel a page unload.

Calling event.preventDefault() will ignore the beforeunload event handler and allow the page to be unloaded.

const {BrowserWindow, dialog} = require('electron')
const win = new BrowserWindow({width: 800, height: 600})
win.webContents.on('will-prevent-unload', (event) => {
  const choice = dialog.showMessageBox(win, {
    type: 'question',
    buttons: ['Leave', 'Stay'],
    title: 'Do you want to leave this site?',
    message: 'Changes you made may not be saved.',
    defaultId: 0,
    cancelId: 1
  const leave = (choice === 0)
  if (leave) {

Event: ‘crashed’


Emitted when the renderer process crashes or is killed.

Event: ‘plugin-crashed’


Emitted when a plugin process has crashed.

Event: ‘destroyed’

Emitted when webContents is destroyed.

Event: ‘before-input-event’


Emitted before dispatching the keydown and keyup events in the page. Calling event.preventDefault will prevent the page keydown/keyup events and the menu shortcuts.

To only prevent the menu shortcuts, use setIgnoreMenuShortcuts:

const {BrowserWindow} = require('electron')

let win = new BrowserWindow({width: 800, height: 600})

win.webContents.on('before-input-event', (event, input) => {
  // For example, only enable application menu keyboard shortcuts when
  // Ctrl/Cmd are down.
  win.webContents.setIgnoreMenuShortcuts(!input.control && !input.meta)

Event: ‘devtools-opened’

Emitted when DevTools is opened.

Event: ‘devtools-closed’

Emitted when DevTools is closed.

Event: ‘devtools-focused’

Emitted when DevTools is focused / opened.

Event: ‘certificate-error’


Emitted when failed to verify the certificate for url.

The usage is the same with the certificate-error event of app.

Event: ‘select-client-certificate’


Emitted when a client certificate is requested.

The usage is the same with the select-client-certificate event of app.

Event: ‘login’


Emitted when webContents wants to do basic auth.

The usage is the same with the login event of app.

Event: ‘found-in-page’


Emitted when a result is available for [webContents.findInPage] request.

Event: ‘media-started-playing’

Emitted when media starts playing.

Event: ‘media-paused’

Emitted when media is paused or done playing.

Event: ‘did-change-theme-color’

Emitted when a page’s theme color changes. This is usually due to encountering a meta tag:

<meta name='theme-color' content='#ff0000'>

Event: ‘update-target-url’


Emitted when mouse moves over a link or the keyboard moves the focus to a link.

Event: ‘cursor-changed’


Emitted when the cursor’s type changes. The type parameter can be default, crosshair, pointer, text, wait, help, e-resize, n-resize, ne-resize, nw-resize, s-resize, se-resize, sw-resize, w-resize, ns-resize, ew-resize, nesw-resize, nwse-resize, col-resize, row-resize, m-panning, e-panning, n-panning, ne-panning, nw-panning, s-panning, se-panning, sw-panning, w-panning, move, vertical-text, cell, context-menu, alias, progress, nodrop, copy, none, not-allowed, zoom-in, zoom-out, grab, grabbing, custom.

If the type parameter is custom, the image parameter will hold the custom cursor image in a NativeImage, and scale, size and hotspot will hold additional information about the custom cursor.

Event: ‘context-menu’


Emitted when there is a new context menu that needs to be handled.

Event: ‘select-bluetooth-device’


Emitted when bluetooth device needs to be selected on call to navigator.bluetooth.requestDevice. To use navigator.bluetooth api webBluetooth should be enabled. If event.preventDefault is not called, first available device will be selected. callback should be called with deviceId to be selected, passing empty string to callback will cancel the request.

const {app, webContents} = require('electron')

app.on('ready', () => {
  webContents.on('select-bluetooth-device', (event, deviceList, callback) => {
    let result = deviceList.find((device) => {
      return device.deviceName === 'test'
    if (!result) {
    } else {

Event: ‘paint’


Emitted when a new frame is generated. Only the dirty area is passed in the buffer.

const {BrowserWindow} = require('electron')

let win = new BrowserWindow({webPreferences: {offscreen: true}})
win.webContents.on('paint', (event, dirty, image) => {
  // updateBitmap(dirty, image.getBitmap())

Event: ‘devtools-reload-page’

Emitted when the devtools window instructs the webContents to reload

Event: ‘will-attach-webview’


Emitted when a <webview>’s web contents is being attached to this web contents. Calling event.preventDefault() will destroy the guest page.

This event can be used to configure webPreferences for the webContents of a <webview> before it’s loaded, and provides the ability to set settings that can’t be set via <webview> attributes.

Note: The specified preload script option will be appear as preloadURL (not preload) in the webPreferences object emitted with this event.

Instance Methods

contents.loadURL(url[, options])

Loads the url in the window. The url must contain the protocol prefix, e.g. the http:// or file://. If the load should bypass http cache then use the pragma header to achieve it.

const {webContents} = require('electron')
const options = {extraHeaders: 'pragma: no-cache\n'}
webContents.loadURL('https://github.com', options)


Initiates a download of the resource at url without navigating. The will-download event of session will be triggered.


Returns String - The URL of the current web page.

const {BrowserWindow} = require('electron')
let win = new BrowserWindow({width: 800, height: 600})

let currentURL = win.webContents.getURL()


Returns String - The title of the current web page.


Returns Boolean - Whether the web page is destroyed.


Focuses the web page.


Returns Boolean - Whether the web page is focused.


Returns Boolean - Whether web page is still loading resources.


Returns Boolean - Whether the main frame (and not just iframes or frames within it) is still loading.


Returns Boolean - Whether the web page is waiting for a first-response from the main resource of the page.


Stops any pending navigation.


Reloads the current web page.


Reloads current page and ignores cache.


Returns Boolean - Whether the browser can go back to previous web page.


Returns Boolean - Whether the browser can go forward to next web page.


Returns Boolean - Whether the web page can go to offset.


Clears the navigation history.


Makes the browser go back a web page.


Makes the browser go forward a web page.


Navigates browser to the specified absolute web page index.


Navigates to the specified offset from the “current entry”.


Returns Boolean - Whether the renderer process has crashed.


Overrides the user agent for this web page.


Returns String - The user agent for this web page.


Injects CSS into the current web page.

contents.executeJavaScript(code[, userGesture, callback])

Returns Promise - A promise that resolves with the result of the executed code or is rejected if the result of the code is a rejected promise.

Evaluates code in page.

In the browser window some HTML APIs like requestFullScreen can only be invoked by a gesture from the user. Setting userGesture to true will remove this limitation.

If the result of the executed code is a promise the callback result will be the resolved value of the promise. We recommend that you use the returned Promise to handle code that results in a Promise.

contents.executeJavaScript('fetch("https://jsonplaceholder.typicode.com/users/1").then(resp => resp.json())', true)
  .then((result) => {
    console.log(result) // Will be the JSON object from the fetch call

contents.setIgnoreMenuShortcuts(ignore) Experimental

Ignore application menu shortcuts while this web contents is focused.


Mute the audio on the current web page.


Returns Boolean - Whether this page has been muted.


Changes the zoom factor to the specified factor. Zoom factor is zoom percent divided by 100, so 300% = 3.0.


Sends a request to get current zoom factor, the callback will be called with callback(zoomFactor).


Changes the zoom level to the specified level. The original size is 0 and each increment above or below represents zooming 20% larger or smaller to default limits of 300% and 50% of original size, respectively.


Sends a request to get current zoom level, the callback will be called with callback(zoomLevel).

contents.setZoomLevelLimits(minimumLevel, maximumLevel)

Deprecated: Call setVisualZoomLevelLimits instead to set the visual zoom level limits. This method will be removed in Electron 2.0.

contents.setVisualZoomLevelLimits(minimumLevel, maximumLevel)

Sets the maximum and minimum pinch-to-zoom level.

contents.setLayoutZoomLevelLimits(minimumLevel, maximumLevel)

Sets the maximum and minimum layout-based (i.e. non-visual) zoom level.


Executes the editing command undo in web page.


Executes the editing command redo in web page.


Executes the editing command cut in web page.


Executes the editing command copy in web page.

contents.copyImageAt(x, y)

Copy the image at the given position to the clipboard.


Executes the editing command paste in web page.


Executes the editing command pasteAndMatchStyle in web page.


Executes the editing command delete in web page.


Executes the editing command selectAll in web page.


Executes the editing command unselect in web page.


Executes the editing command replace in web page.


Executes the editing command replaceMisspelling in web page.


Inserts text to the focused element.

contents.findInPage(text[, options])

Starts a request to find all matches for the text in the web page and returns an Integer representing the request id used for the request. The result of the request can be obtained by subscribing to found-in-page event.


Stops any findInPage request for the webContents with the provided action.

const {webContents} = require('electron')
webContents.on('found-in-page', (event, result) => {
  if (result.finalUpdate) webContents.stopFindInPage('clearSelection')

const requestId = webContents.findInPage('api')

contents.capturePage([rect, ]callback)

Captures a snapshot of the page within rect. Upon completion callback will be called with callback(image). The image is an instance of NativeImage that stores data of the snapshot. Omitting rect will capture the whole visible page.


Checks if any ServiceWorker is registered and returns a boolean as response to callback.


Unregisters any ServiceWorker if present and returns a boolean as response to callback when the JS promise is fulfilled or false when the JS promise is rejected.


Get the system printer list.

Returns PrinterInfo[]


Prints window’s web page. When silent is set to true, Electron will pick the system’s default printer if deviceName is empty and the default settings for printing.

Calling window.print() in web page is equivalent to calling webContents.print({silent: false, printBackground: false, deviceName: ''}).

Use page-break-before: always; CSS style to force to print to a new page.

contents.printToPDF(options, callback)

Prints window’s web page as PDF with Chromium’s preview printing custom settings.

The callback will be called with callback(error, data) on completion. The data is a Buffer that contains the generated PDF data.

The landscape will be ignored if @page CSS at-rule is used in the web page.

By default, an empty options will be regarded as:

  marginsType: 0,
  printBackground: false,
  printSelectionOnly: false,
  landscape: false

Use page-break-before: always; CSS style to force to print to a new page.

An example of webContents.printToPDF:

const {BrowserWindow} = require('electron')
const fs = require('fs')

let win = new BrowserWindow({width: 800, height: 600})

win.webContents.on('did-finish-load', () => {
  // Use default printing options
  win.webContents.printToPDF({}, (error, data) => {
    if (error) throw error
    fs.writeFile('/tmp/print.pdf', data, (error) => {
      if (error) throw error
      console.log('Write PDF successfully.')


Adds the specified path to DevTools workspace. Must be used after DevTools creation:

const {BrowserWindow} = require('electron')
let win = new BrowserWindow()
win.webContents.on('devtools-opened', () => {


Removes the specified path from DevTools workspace.


Opens the devtools.


Closes the devtools.


Returns Boolean - Whether the devtools is opened.


Returns Boolean - Whether the devtools view is focused .


Toggles the developer tools.

contents.inspectElement(x, y)

Starts inspecting element at position (x, y).


Opens the developer tools for the service worker context.

contents.send(channel[, arg1][, arg2][, ...])

Send an asynchronous message to renderer process via channel, you can also send arbitrary arguments. Arguments will be serialized in JSON internally and hence no functions or prototype chain will be included.

The renderer process can handle the message by listening to channel with the ipcRenderer module.

An example of sending messages from the main process to the renderer process:

// In the main process.
const {app, BrowserWindow} = require('electron')
let win = null

app.on('ready', () => {
  win = new BrowserWindow({width: 800, height: 600})
  win.webContents.on('did-finish-load', () => {
    win.webContents.send('ping', 'whoooooooh!')
<!-- index.html -->
    require('electron').ipcRenderer.on('ping', (event, message) => {
      console.log(message)  // Prints 'whoooooooh!'


Enable device emulation with the given parameters.


Disable device emulation enabled by webContents.enableDeviceEmulation.


Sends an input event to the page. Note: The BrowserWindow containing the contents needs to be focused for sendInputEvent() to work.

For keyboard events, the event object also have following properties:

For mouse events, the event object also have following properties:

For the mouseWheel event, the event object also have following properties:

contents.beginFrameSubscription([onlyDirty ,]callback)

Begin subscribing for presentation events and captured frames, the callback will be called with callback(frameBuffer, dirtyRect) when there is a presentation event.

The frameBuffer is a Buffer that contains raw pixel data. On most machines, the pixel data is effectively stored in 32bit BGRA format, but the actual representation depends on the endianness of the processor (most modern processors are little-endian, on machines with big-endian processors the data is in 32bit ARGB format).

The dirtyRect is an object with x, y, width, height properties that describes which part of the page was repainted. If onlyDirty is set to true, frameBuffer will only contain the repainted area. onlyDirty defaults to false.


End subscribing for frame presentation events.


Sets the item as dragging item for current drag-drop operation, file is the absolute path of the file to be dragged, and icon is the image showing under the cursor when dragging.

contents.savePage(fullPath, saveType, callback)

Returns Boolean - true if the process of saving page has been initiated successfully.

const {BrowserWindow} = require('electron')
let win = new BrowserWindow()


win.webContents.on('did-finish-load', () => {
  win.webContents.savePage('/tmp/test.html', 'HTMLComplete', (error) => {
    if (!error) console.log('Save page successfully')

contents.showDefinitionForSelection() macOS

Shows pop-up dictionary that searches the selected word on the page.


Set the size of the page. This is only supported for <webview> guest contents.


Returns Boolean - Indicates whether offscreen rendering is enabled.


If offscreen rendering is enabled and not painting, start painting.


If offscreen rendering is enabled and painting, stop painting.


Returns Boolean - If offscreen rendering is enabled returns whether it is currently painting.


If offscreen rendering is enabled sets the frame rate to the specified number. Only values between 1 and 60 are accepted.


Returns Integer - If offscreen rendering is enabled returns the current frame rate.


Schedules a full repaint of the window this web contents is in.

If offscreen rendering is enabled invalidates the frame and generates a new one through the 'paint' event.


Returns String - Returns the WebRTC IP Handling Policy.


Setting the WebRTC IP handling policy allows you to control which IPs are exposed via WebRTC. See BrowserLeaks for more details.


Returns Integer - The pid of the associated renderer process.

Instance Properties


A Integer representing the unique ID of this WebContents.


A Session used by this webContents.


A WebContents instance that might own this WebContents.


A WebContents of DevTools for this WebContents.

Note: Users should never store this object because it may become null when the DevTools has been closed.


A Debugger instance for this webContents.

See something that needs fixing? Propose a change on the source.
Need a different version of the docs? See the available versions or community translations.
Want to search all the documentation at once? See all of the docs on one page.