Nodriver

https://ultrafunkamsterdam.github.io/nodriver
Admin
Nodriver is an asynchronous Python library for blazing fast, undetected web scraping and browser...
Tokens:465,497
Snippets:2,934
Trust Score:8.3
Update:2 months ago
Show doc for...
Tokens:
Raw
### Basic Browser Usage

Source: https://ultrafunkamsterdam.github.io/nodriver/nodriver/quickstart.html

A minimal example to start a browser and navigate to a URL.

```python
import nodriver as uc

async def main():

    browser = await uc.start()
    page = await browser.get('https://www.nowsecure.nl')

    ... further code ...

if __name__ == '__main__':
    # since asyncio.run never worked (for me)
    uc.loop().run_until_complete(main())
```

--------------------------------

### Installation

Source: https://ultrafunkamsterdam.github.io/nodriver/readme.html

Install the package using pip.

```bash
pip install nodriver
```

--------------------------------

### install

Source: https://ultrafunkamsterdam.github.io/nodriver/nodriver/cdp/pwa.html

Installs the given manifest identity.

```APIDOC
## install(manifest_id, install_url_or_bundle_url=None)

### Description
Installs the given manifest identity, optionally using the given installUrlOrBundleUrl.

### Parameters
- **manifest_id** (str) - Required
- **install_url_or_bundle_url** (Optional[str]) - Optional - The location of the app or bundle overriding the one derived from the manifestId.
```

--------------------------------

### install(manifest_id: str, install_url_or_bundle_url: Optional[str] = None)

Source: https://ultrafunkamsterdam.github.io/nodriver/_modules/nodriver/cdp/pwa.html

Installs a PWA using the provided manifest identity and optional install or bundle URL.

```APIDOC
## install

### Description
Installs the given manifest identity. Supports standard PWA installation and Isolated Web App (IWA) installation modes including file-based bundles and dev proxy mode.

### Parameters
- **manifest_id** (str) - Required - The manifest identity.
- **install_url_or_bundle_url** (str) - Optional - The URL pointing to the install source or signed web bundle.
```

--------------------------------

### Install a PWA

Source: https://ultrafunkamsterdam.github.io/nodriver/_modules/nodriver/cdp/pwa.html

Installs a PWA using its manifest ID and an optional install or bundle URL.

```python
params: T_JSON_DICT = dict()
params['manifestId'] = manifest_id
if install_url_or_bundle_url is not None:
    params['installUrlOrBundleUrl'] = install_url_or_bundle_url
cmd_dict: T_JSON_DICT = {
    'method': 'PWA.install',
    'params': params,
}
json = yield cmd_dict
```

--------------------------------

### Install nodriver

Source: https://ultrafunkamsterdam.github.io/nodriver/nodriver/quickstart.html

Installation commands for the library.

```bash
# todo. use pip install nodriver instead
pip install undetected-chromedriver
```

```bash
pip install nodriver
```

--------------------------------

### start_desktop_mirroring(sink_name)

Source: https://ultrafunkamsterdam.github.io/nodriver/nodriver/cdp/cast.html

Starts mirroring the desktop to the specified sink.

```APIDOC
## start_desktop_mirroring(sink_name)

### Description
Starts mirroring the desktop to the sink.

### Parameters
- **sink_name** (str) - Required - The name of the sink to mirror to.
```

--------------------------------

### start(categories=None, options=None, buffer_usage_reporting_interval=None, transfer_mode=None, stream_format=None, stream_compression=None, trace_config=None, perfetto_config=None, tracing_backend=None)

Source: https://ultrafunkamsterdam.github.io/nodriver/nodriver/cdp/tracing.html

Start trace events collection.

```APIDOC
## start(...)

### Description
Start trace events collection.

### Parameters
- **categories** (Optional[str]) - Optional. DEPRECATED/EXPERIMENTAL. Category/tag filter.
- **options** (Optional[str]) - Optional. DEPRECATED/EXPERIMENTAL. Tracing options.
- **buffer_usage_reporting_interval** (Optional[float]) - Optional. EXPERIMENTAL. If set, the agent will issue bufferUsage events at this interval (ms).
- **transfer_mode** (Optional[str]) - Optional. Whether to report trace events as series of dataCollected events or to save trace to a stream.
- **stream_format** (Optional[StreamFormat]) - Optional. Trace data format to use.
- **stream_compression** (Optional[StreamCompression]) - Optional. EXPERIMENTAL. Compression format to use.
- **trace_config** (Optional[TraceConfig]) - Optional.
- **perfetto_config** (Optional[str]) - Optional. EXPERIMENTAL. Base64-encoded serialized perfetto.protos.TraceConfig protobuf message.
- **tracing_backend** (Optional[TracingBackend]) - Optional. EXPERIMENTAL. Backend type.

### Return Type
`Generator[Dict[str, Any], Dict[str, Any], None]`
```

--------------------------------

### Cast.startDesktopMirroring

Source: https://ultrafunkamsterdam.github.io/nodriver/_modules/nodriver/cdp/cast.html

Starts mirroring the desktop to the specified sink.

```APIDOC
## Cast.startDesktopMirroring

### Description
Starts mirroring the desktop to the sink.

### Parameters
- **sinkName** (string) - Required - The name of the sink to mirror to.
```

--------------------------------

### install(manifest_id)

Source: https://ultrafunkamsterdam.github.io/nodriver/nodriver/cdp/pwa.html

Installs the PWA identified by the manifest_id.

```APIDOC
## install(manifest_id)

### Description
Installs the PWA identified by the manifest_id.

### Parameters
- **manifest_id** (str) - Required
```

--------------------------------

### launch

Source: https://ultrafunkamsterdam.github.io/nodriver/nodriver/cdp/pwa.html

Launches the installed web app.

```APIDOC
## launch(manifest_id, url=None)

### Description
Launches the installed web app, or an url in the same web app instead of the default start url if it is provided.

### Parameters
- **manifest_id** (str) - Required
- **url** (Optional[str]) - Optional

### Response
- **TargetID** (str) - ID of the tab target created as a result.
```

--------------------------------

### PWA.install

Source: https://ultrafunkamsterdam.github.io/nodriver/_modules/nodriver/cdp/pwa.html

Installs a PWA using the provided manifest ID and optional install URL.

```APIDOC
## PWA.install

### Description
Installs a PWA identified by its manifest ID. An optional install URL or bundle URL can be provided to override the default location.

### Parameters
- **manifest_id** (str) - Required - The ID of the manifest.
- **install_url_or_bundle_url** (str) - Optional - The location of the app or bundle.
```

--------------------------------

### PWA.launch

Source: https://ultrafunkamsterdam.github.io/nodriver/_modules/nodriver/cdp/pwa.html

Launches an installed PWA.

```APIDOC
## PWA.launch

### Description
Launches the installed web app. Optionally, a specific URL can be provided to open within the app instead of the default start URL.

### Parameters
- **manifest_id** (str) - Required - The ID of the manifest.
- **url** (str) - Optional - The URL to open.

### Returns
- **TargetID** - The ID of the created page target.
```

--------------------------------

### Start Sampling

Source: https://ultrafunkamsterdam.github.io/nodriver/_modules/nodriver/cdp/heap_profiler.html

Starts the sampling heap profiler with optional configuration for GC collection inclusion.

```python
def start_sampling(
        sampling_interval: typing.Optional[float] = None,
        include_objects_collected_by_major_gc: typing.Optional[bool] = None,
        include_objects_collected_by_minor_gc: typing.Optional[bool] = None
    ) -> typing.Generator[T_JSON_DICT,T_JSON_DICT,None]:
    '''
    :param sampling_interval: *(Optional)* Average sample interval in bytes. Poisson distribution is used for the intervals. The default value is 32768 bytes.
    :param include_objects_collected_by_major_gc: *(Optional)* By default, the sampling heap profiler reports only objects which are still alive when the profile is returned via getSamplingProfile or stopSampling, which is useful for determining what functions contribute the most to steady-state memory usage. This flag instructs the sampling heap profiler to also include information about objects discarded by major GC, which will show which functions cause large temporary memory usage or long GC pauses.
    :param include_objects_collected_by_minor_gc: *(Optional)* By default, the sampling heap profiler reports only objects which are still alive when the profile is returned via getSamplingProfile or stopSampling, which is useful for determining what functions contribute the most to steady-state memory usage. This flag instructs the sampling heap profiler to also include information about objects discarded by minor GC, which is useful when tuning a latency-sensitive application for minimal GC activity.
    '''
    params: T_JSON_DICT = dict()
    if sampling_interval is not None:
        params['samplingInterval'] = sampling_interval
    if include_objects_collected_by_major_gc is not None:
        params['includeObjectsCollectedByMajorGC'] = include_objects_collected_by_major_gc
    if include_objects_collected_by_minor_gc is not None:
        params['includeObjectsCollectedByMinorGC'] = include_objects_collected_by_minor_gc
    cmd_dict: T_JSON_DICT = {
        'method': 'HeapProfiler.startSampling',
        'params': params,
    }
    json = yield cmd_dict
```

--------------------------------

### Launch a PWA

Source: https://ultrafunkamsterdam.github.io/nodriver/_modules/nodriver/cdp/pwa.html

Launches an installed web app, optionally navigating to a specific URL instead of the default start URL.

```python
params: T_JSON_DICT = dict()
params['manifestId'] = manifest_id
if url is not None:
    params['url'] = url
cmd_dict: T_JSON_DICT = {
    'method': 'PWA.launch',
    'params': params,
}
json = yield cmd_dict
return target.TargetID.from_json(json['targetId'])
```

--------------------------------

### Start Tracking Heap Objects

Source: https://ultrafunkamsterdam.github.io/nodriver/_modules/nodriver/cdp/heap_profiler.html

Starts tracking heap object allocations.

```python
def start_tracking_heap_objects(
        track_allocations: typing.Optional[bool] = None
    ) -> typing.Generator[T_JSON_DICT,T_JSON_DICT,None]:
    '''
    :param track_allocations: *(Optional)*
    '''
    params: T_JSON_DICT = dict()
    if track_allocations is not None:
        params['trackAllocations'] = track_allocations
    cmd_dict: T_JSON_DICT = {
        'method': 'HeapProfiler.startTrackingHeapObjects',
        'params': params,
    }
    json = yield cmd_dict
```

--------------------------------

### Get Installability Errors

Source: https://ultrafunkamsterdam.github.io/nodriver/_modules/nodriver/cdp/page.html

Retrieves installability errors for the page. This is an experimental feature.

```python
def get_installability_errors() -> typing.Generator[T_JSON_DICT,T_JSON_DICT,typing.List[InstallabilityError]]:
    '''


    **EXPERIMENTAL**

    :returns: 
    '''
    cmd_dict: T_JSON_DICT = {
        'method': 'Page.getInstallabilityErrors',
    }
    json = yield cmd_dict
    return [InstallabilityError.from_json(i) for i in json['installabilityErrors']]
```

--------------------------------

### Profiler.start

Source: https://ultrafunkamsterdam.github.io/nodriver/_modules/nodriver/cdp/profiler.html

Starts the profiler.

```APIDOC
## Profiler.start

### Description
Starts the profiler.
```

--------------------------------

### start_sampling

Source: https://ultrafunkamsterdam.github.io/nodriver/nodriver/cdp/memory.html

Start collecting native memory profile.

```APIDOC
## start_sampling(sampling_interval=None, suppress_randomness=None)

### Description
Start collecting native memory profile.

### Parameters
- **sampling_interval** (int) - Optional - Average number of bytes between samples.
- **suppress_randomness** (bool) - Optional - Do not randomize intervals between samples.
```

--------------------------------

### enable(presentation_url=None)

Source: https://ultrafunkamsterdam.github.io/nodriver/nodriver/cdp/cast.html

Starts observing for sinks that can be used for tab mirroring, and if set, sinks compatible with presentationUrl as well. Also starts observing for issue messages.

```APIDOC
## enable(presentation_url=None)

### Description
Starts observing for sinks that can be used for tab mirroring, and if set, sinks compatible with presentationUrl as well. When sinks are found, a sinksUpdated event is fired. Also starts observing for issue messages.

### Parameters
- **presentation_url** (Optional[str]) - Optional - The URL to filter compatible sinks.
```

--------------------------------

### Install Unpacked Extension

Source: https://ultrafunkamsterdam.github.io/nodriver/_modules/nodriver/cdp/extensions.html

Installs an extension from a local path. Requires --remote-debugging-pipe and --enable-unsafe-extension-debugging flags.

```python
def load_unpacked(
        path: str
    ) -> typing.Generator[T_JSON_DICT,T_JSON_DICT,str]:
    '''
    Installs an unpacked extension from the filesystem similar to
    --load-extension CLI flags. Returns extension ID once the extension
    has been installed. Available if the client is connected using the
    --remote-debugging-pipe flag and the --enable-unsafe-extension-debugging
    flag is set.

    :param path: Absolute file path.
    :returns: Extension id.
    '''
    params: T_JSON_DICT = dict()
    params['path'] = path
    cmd_dict: T_JSON_DICT = {
        'method': 'Extensions.loadUnpacked',
        'params': params,
    }
    json = yield cmd_dict
    return str(json['id'])
```

--------------------------------

### Start Screencast

Source: https://ultrafunkamsterdam.github.io/nodriver/_modules/nodriver/cdp/page.html

Initiates a screencast session with optional parameters for format, quality, and dimensions.

```python
def start_screencast(
        format_: typing.Optional[str] = None,
        quality: typing.Optional[int] = None,
        max_width: typing.Optional[int] = None,
        max_height: typing.Optional[int] = None,
        every_nth_frame: typing.Optional[int] = None
    ) -> typing.Generator[T_JSON_DICT,T_JSON_DICT,None]:
    '''
    Starts sending each frame using the ``screencastFrame`` event.

    **EXPERIMENTAL**

    :param format_: *(Optional)* Image compression format.
    :param quality: *(Optional)* Compression quality from range [0..100].
    :param max_width: *(Optional)* Maximum screenshot width.
    :param max_height: *(Optional)* Maximum screenshot height.
    :param every_nth_frame: *(Optional)* Send every n-th frame.
    '''
    params: T_JSON_DICT = dict()
    if format_ is not None:
        params['format'] = format_
    if quality is not None:
        params['quality'] = quality
    if max_width is not None:
        params['maxWidth'] = max_width
    if max_height is not None:
        params['maxHeight'] = max_height
    if every_nth_frame is not None:
        params['everyNthFrame'] = every_nth_frame
    cmd_dict: T_JSON_DICT = {
        'method': 'Page.startScreencast',
        'params': params,
    }
    json = yield cmd_dict
```

--------------------------------

### Install PWA manifest

Source: https://ultrafunkamsterdam.github.io/nodriver/_modules/nodriver/cdp/pwa.html

Function to install a PWA using a manifest ID, supporting standard, IWA, and dev proxy installation modes.

```python
def install(
        manifest_id: str,
        install_url_or_bundle_url: typing.Optional[str] = None
    ) -> typing.Generator[T_JSON_DICT,T_JSON_DICT,None]:
    '''
    Installs the given manifest identity, optionally using the given installUrlOrBundleUrl

    IWA-specific install description:
    manifestId corresponds to isolated-app:// + web_package::SignedWebBundleId

    File installation mode:
    The installUrlOrBundleUrl can be either file:// or http(s):// pointing
    to a signed web bundle (.swbn). In this case SignedWebBundleId must correspond to
    The .swbn file's signing key.

    Dev proxy installation mode:
    installUrlOrBundleUrl must be http(s):// that serves dev mode IWA.
    web_package::SignedWebBundleId must be of type dev proxy.

    The advantage of dev proxy mode is that all changes to IWA
    automatically will be reflected in the running app without
    reinstallation.

    To generate bundle id for proxy mode:
    1. Generate 32 random bytes.
    2. Add a specific suffix at the end following the documentation
       https://github.com/WICG/isolated-web-apps/blob/main/Scheme.md#suffix
    3. Encode the entire sequence using Base32 without padding.

    If Chrome is not in IWA dev
    mode, the installation will fail, regardless of the state of the allowlist.
```

--------------------------------

### HeapProfiler.startSampling

Source: https://ultrafunkamsterdam.github.io/nodriver/_modules/nodriver/cdp/heap_profiler.html

Starts the sampling heap profiler.

```APIDOC
## HeapProfiler.startSampling

### Description
Starts collecting a sampling heap profile.

### Parameters
- **sampling_interval** (float) - Optional - Average sample interval in bytes. Default is 32768.
- **include_objects_collected_by_major_gc** (boolean) - Optional - Include objects discarded by major GC.
- **include_objects_collected_by_minor_gc** (boolean) - Optional - Include objects discarded by minor GC.
```

--------------------------------

### Memory.startSampling

Source: https://ultrafunkamsterdam.github.io/nodriver/_modules/nodriver/cdp/memory.html

Starts the collection of a native memory profile.

```APIDOC
## Memory.startSampling

### Description
Start collecting native memory profile.

### Parameters
- **sampling_interval** (integer) - Optional - Average number of bytes between samples.
- **suppress_randomness** (boolean) - Optional - Do not randomize intervals between samples.
```

--------------------------------

### Extensions.loadUnpacked

Source: https://ultrafunkamsterdam.github.io/nodriver/_modules/nodriver/cdp/extensions.html

Installs an unpacked extension from the filesystem. Returns the extension ID upon successful installation.

```APIDOC
## Extensions.loadUnpacked

### Description
Installs an unpacked extension from the filesystem similar to --load-extension CLI flags. Available if the client is connected using the --remote-debugging-pipe flag and the --enable-unsafe-extension-debugging flag is set.

### Parameters
- **path** (string) - Required - Absolute file path to the extension.

### Returns
- **id** (string) - The extension ID.
```

--------------------------------

### Browser.downloadWillBegin

Source: https://ultrafunkamsterdam.github.io/nodriver/_modules/nodriver/cdp/browser.html

Event fired when a page is about to start a download.

```APIDOC
## Browser.downloadWillBegin

### Description
Experimental event fired when a page is about to start a download.

### Fields
- **frame_id** (FrameId) - Id of the frame that caused the download to begin.
- **guid** (string) - Global unique identifier of the download.
- **url** (string) - URL of the resource being downloaded.
- **suggested_filename** (string) - Suggested file name of the resource.
```

--------------------------------

### Page.getInstallabilityErrors

Source: https://ultrafunkamsterdam.github.io/nodriver/_modules/nodriver/cdp/page.html

Retrieves installability errors for the page.

```APIDOC
## Page.getInstallabilityErrors

### Description
Retrieves installability errors. (EXPERIMENTAL)
```

--------------------------------

### PWA.launchFilesInApp

Source: https://ultrafunkamsterdam.github.io/nodriver/_modules/nodriver/cdp/pwa.html

Opens local files within an installed PWA.

```APIDOC
## PWA.launchFilesInApp

### Description
Opens one or more local files using an installed web app that has registered file handlers. Returns the target IDs for the pages handling the files.

### Parameters
- **manifest_id** (str) - Required - The ID of the manifest.
- **files** (List[str]) - Required - A list of file paths to open.

### Returns
- **List[TargetID]** - A list of target IDs created for the files.
```

--------------------------------

### Execute Tracing.start command

Source: https://ultrafunkamsterdam.github.io/nodriver/_modules/nodriver/cdp/tracing.html

Starts the collection of trace events with various configuration options.

```python
def start(
        categories: typing.Optional[str] = None,
        options: typing.Optional[str] = None,
        buffer_usage_reporting_interval: typing.Optional[float] = None,
        transfer_mode: typing.Optional[str] = None,
        stream_format: typing.Optional[StreamFormat] = None,
        stream_compression: typing.Optional[StreamCompression] = None,
        trace_config: typing.Optional[TraceConfig] = None,
        perfetto_config: typing.Optional[str] = None,
        tracing_backend: typing.Optional[TracingBackend] = None
    ) -> typing.Generator[T_JSON_DICT,T_JSON_DICT,None]:
    '''
    Start trace events collection.
```

--------------------------------

### Start Tracing Command

Source: https://ultrafunkamsterdam.github.io/nodriver/_modules/nodriver/cdp/tracing.html

Constructs the Tracing.start command dictionary with optional configuration parameters.

```python
    params: T_JSON_DICT = dict()
    if categories is not None:
        params['categories'] = categories
    if options is not None:
        params['options'] = options
    if buffer_usage_reporting_interval is not None:
        params['bufferUsageReportingInterval'] = buffer_usage_reporting_interval
    if transfer_mode is not None:
        params['transferMode'] = transfer_mode
    if stream_format is not None:
        params['streamFormat'] = stream_format.to_json()
    if stream_compression is not None:
        params['streamCompression'] = stream_compression.to_json()
    if trace_config is not None:
        params['traceConfig'] = trace_config.to_json()
    if perfetto_config is not None:
        params['perfettoConfig'] = perfetto_config
    if tracing_backend is not None:
        params['tracingBackend'] = tracing_backend.to_json()
    cmd_dict: T_JSON_DICT = {
        'method': 'Tracing.start',
        'params': params,
    }
    json = yield cmd_dict
```

--------------------------------

### start_tab_mirroring(sink_name)

Source: https://ultrafunkamsterdam.github.io/nodriver/nodriver/cdp/cast.html

Starts mirroring the current tab to the specified sink.

```APIDOC
## start_tab_mirroring(sink_name)

### Description
Starts mirroring the tab to the sink.

### Parameters
- **sink_name** (str) - Required - The name of the sink to mirror to.
```

--------------------------------

### HeapProfiler.startTrackingHeapObjects

Source: https://ultrafunkamsterdam.github.io/nodriver/_modules/nodriver/cdp/heap_profiler.html

Starts tracking heap object allocations.

```APIDOC
## HeapProfiler.startTrackingHeapObjects

### Description
Starts tracking heap object allocations.

### Parameters
- **track_allocations** (boolean) - Optional
```

--------------------------------

### WebAudio.enable

Source: https://ultrafunkamsterdam.github.io/nodriver/_modules/nodriver/cdp/web_audio.html

Enables the WebAudio domain and starts sending context lifetime events.

```APIDOC
## WebAudio.enable

### Description
Enables the WebAudio domain and starts sending context lifetime events.
```

--------------------------------

### Page.startScreencast

Source: https://ultrafunkamsterdam.github.io/nodriver/_modules/nodriver/cdp/page.html

Starts sending each frame using the screencastFrame event.

```APIDOC
## Page.startScreencast

### Description
Starts sending each frame using the screencastFrame event. This method is experimental.

### Parameters
- **format_** (string) - Optional - Image compression format.
- **quality** (integer) - Optional - Compression quality from range [0..100].
- **max_width** (integer) - Optional - Maximum screenshot width.
- **max_height** (integer) - Optional - Maximum screenshot height.
- **every_nth_frame** (integer) - Optional - Send every n-th frame.
```

--------------------------------

### Start memory sampling

Source: https://ultrafunkamsterdam.github.io/nodriver/_modules/nodriver/cdp/memory.html

Initiates the collection of a native memory profile.

```python
def start_sampling(
        sampling_interval: typing.Optional[int] = None,
        suppress_randomness: typing.Optional[bool] = None
    ) -> typing.Generator[T_JSON_DICT,T_JSON_DICT,None]:
    '''
    Start collecting native memory profile.

    :param sampling_interval: *(Optional)* Average number of bytes between samples.
    :param suppress_randomness: *(Optional)* Do not randomize intervals between samples.
    '''
    params: T_JSON_DICT = dict()
    if sampling_interval is not None:
        params['samplingInterval'] = sampling_interval
    if suppress_randomness is not None:
        params['suppressRandomness'] = suppress_randomness
    cmd_dict: T_JSON_DICT = {
        'method': 'Memory.startSampling',
        'params': params,
    }
    json = yield cmd_dict
```

--------------------------------

### Force Starting Style

Source: https://ultrafunkamsterdam.github.io/nodriver/_modules/nodriver/cdp/css.html

Ensures that the given node is in its starting-style state.

```python
[docs]
def force_starting_style(
        node_id: dom.NodeId,
        forced: bool
    ) -> typing.Generator[T_JSON_DICT,T_JSON_DICT,None]:
    '''
    Ensures that the given node is in its starting-style state.

    :param node_id: The element id for which to force the starting-style state.
    :param forced: Boolean indicating if this is on or off.
    '''
    params: T_JSON_DICT = dict()
    params['nodeId'] = node_id.to_json()
    params['forced'] = forced
    cmd_dict: T_JSON_DICT = {
        'method': 'CSS.forceStartingStyle',
        'params': params,
    }
    json = yield cmd_dict
```

--------------------------------

### Start Rule Usage Tracking

Source: https://ultrafunkamsterdam.github.io/nodriver/_modules/nodriver/cdp/css.html

Enables recording of CSS selector usage.

```python
def start_rule_usage_tracking() -> typing.Generator[T_JSON_DICT,T_JSON_DICT,None]:
    '''
    Enables the selector recording.
    '''
    cmd_dict: T_JSON_DICT = {
        'method': 'CSS.startRuleUsageTracking',
    }
    json = yield cmd_dict
```

--------------------------------

### launch_files_in_app

Source: https://ultrafunkamsterdam.github.io/nodriver/nodriver/cdp/pwa.html

Opens one or more local files from an installed web app.

```APIDOC
## launch_files_in_app(manifest_id, files)

### Description
Opens one or more local files from an installed web app identified by its manifestId. The web app needs to have file handlers registered to process the files.

### Parameters
- **manifest_id** (str) - Required
- **files** (list) - Required
```

--------------------------------

### Get Screen Information

Source: https://ultrafunkamsterdam.github.io/nodriver/_modules/nodriver/cdp/emulation.html

Retrieves the device's screen configuration.

```python
def get_screen_infos() -> typing.Generator[T_JSON_DICT,T_JSON_DICT,typing.List[ScreenInfo]]:
    '''
    Returns device's screen configuration.

    **EXPERIMENTAL**

    :returns: 
    '''
    cmd_dict: T_JSON_DICT = {
        'method': 'Emulation.getScreenInfos',
    }
    json = yield cmd_dict
    return [ScreenInfo.from_json(i) for i in json['screenInfos']]
```

--------------------------------

### start

Source: https://ultrafunkamsterdam.github.io/nodriver/_modules/nodriver/core/browser.html

Launches the browser process. It is recommended to use Browser.create() instead of calling this method directly.

```APIDOC
## start()

### Description
Launches the actual browser process. If the browser is already running, this call has no effect.

### Returns
- **Browser** - The launched browser instance.
```

--------------------------------

### enable

Source: https://ultrafunkamsterdam.github.io/nodriver/nodriver/cdp/web_authn.html

Enables the WebAuthn domain and starts intercepting credential storage and retrieval.

```APIDOC
## enable(enable_ui=None)

### Description
Enable the WebAuthn domain and start intercepting credential storage and retrieval with a virtual authenticator.

### Parameters
- **enable_ui** (bool) - Optional - Whether to enable the WebAuthn user interface. Defaults to false.
```

--------------------------------

### Browser.create

Source: https://ultrafunkamsterdam.github.io/nodriver/_modules/nodriver/core/browser.html

Asynchronously creates and starts a new Browser instance. This is the recommended way to initialize the browser.

```APIDOC
## Browser.create

### Description
Creates an instance of the Browser class and starts the underlying browser process.

### Parameters
- **config** (Config) - Optional - Configuration object for the browser.
- **user_data_dir** (PathLike) - Optional - Directory for user data.
- **headless** (bool) - Optional - Whether to run the browser in headless mode.
- **browser_executable_path** (PathLike) - Optional - Path to the browser executable.
- **browser_args** (List[str]) - Optional - Additional arguments for the browser process.
- **sandbox** (bool) - Optional - Whether to enable the browser sandbox.
- **host** (str) - Optional - Host address for the connection.
- **port** (int) - Optional - Port for the connection.

### Returns
- **Browser** - An initialized and started Browser instance.
```

--------------------------------

### Console Profile Started Event

Source: https://ultrafunkamsterdam.github.io/nodriver/_modules/nodriver/cdp/profiler.html

Data class representing the start of a console profile recording.

```python
@event_class('Profiler.consoleProfileStarted')
@dataclass
class ConsoleProfileStarted:
    '''
    Sent when new profile recording is started using console.profile() call.
    '''
    id_: str
    #: Location of console.profile().
    location: debugger.Location
    #: Profile title passed as an argument to console.profile().
    title: typing.Optional[str]

    @classmethod
    def from_json(cls, json: T_JSON_DICT) -> ConsoleProfileStarted:
        return cls(
            id_=str(json['id']),
            location=debugger.Location.from_json(json['location']),
            title=str(json['title']) if json.get('title', None) is not None else None
        )
```

--------------------------------

### Initialize Browser Process and Connection

Source: https://ultrafunkamsterdam.github.io/nodriver/_modules/nodriver/core/browser.html

Handles the asynchronous startup of the browser process, HTTP API initialization, and WebSocket connection setup.

```python
        logger.info(
            "starting\n\texecutable :%s\n\narguments:\n%s", exe, "\n\t".join(params)
        )
        if not connect_existing:
            self._process: asyncio.subprocess.Process = (
                await asyncio.create_subprocess_exec(
                    # self.config.browser_executable_path,
                    # *cmdparams,
                    exe,
                    *params,
                    stdin=asyncio.subprocess.PIPE,
                    stdout=asyncio.subprocess.PIPE,
                    stderr=asyncio.subprocess.PIPE,
                    close_fds=is_posix,
                )
            )
            self._process_pid = self._process.pid

        self._http = HTTPApi((self.config.host, self.config.port))
        util.get_registered_instances().add(self)
        await asyncio.sleep(0.25)
        for _ in range(5):
            try:
                self.info = ContraDict(await self._http.get("version"), silent=True)
            except (Exception,):
                if _ == 4:
                    logger.debug("could not start", exc_info=True)
                await self.sleep(0.5)
            else:
                break

        if not self.info:
            raise Exception(
                (
                    """
                ---------------------
                Failed to connect to browser
                ---------------------
                One of the causes could be when you are running as root.
                In that case you need to pass no_sandbox=True 
                """
                )
            )

        self.connection = Connection(self.info.webSocketDebuggerUrl, browser=self)

        if self.config.autodiscover_targets:
            logger.info("enabling autodiscover targets")

            self.connection.handlers[cdp.target.TargetInfoChanged] = [
                self._handle_target_update
            ]
            self.connection.handlers[cdp.target.TargetCreated] = [
                self._handle_target_update
            ]
            self.connection.handlers[cdp.target.TargetDestroyed] = [
                self._handle_target_update
            ]
            self.connection.handlers[cdp.target.TargetCrashed] = [
                self._handle_target_update
            ]
            await self.connection.send(cdp.target.set_discover_targets(discover=True))

        await self.update_targets()
```

--------------------------------

### Complete Browser Interaction Example

Source: https://ultrafunkamsterdam.github.io/nodriver/nodriver/quickstart.html

Demonstrates taking screenshots, scrolling, selecting elements, and managing multiple tabs and windows.

```python
import nodriver

async def main():

    browser = await nodriver.start()
    page = await browser.get('https://www.nowsecure.nl')

    await page.save_screenshot()
    await page.get_content()
    await page.scroll_down(150)
    elems = await page.select_all('*[src]')

    for elem in elems:
        await elem.flash()

    page2 = await browser.get('https://twitter.com', new_tab=True)
    page3 = await browser.get('https://github.com/ultrafunkamsterdam/nodriver', new_window=True)

    for p in (page, page2, page3):
       await p.bring_to_front()
       await p.scroll_down(200)
       await p   # wait for events to be processed
       await p.reload()
       if p != page3:
           await p.close()

if __name__ == '__main__':

    # since asyncio.run never worked (for me)
    uc.loop().run_until_complete(main())
```

--------------------------------

### Launch the browser instance

Source: https://ultrafunkamsterdam.github.io/nodriver/_modules/nodriver/core/browser.html

Initializes and launches the browser process. It validates the executable path and configures extensions if provided.

```python
    async def start(self=None) -> Browser:
        """launches the actual browser"""
        if not self:
            warnings.warn("use ``await Browser.create()`` to create a new instance")
            return

        if self._process or self._process_pid:
            if self._process.returncode is not None:
                return await self.create(config=self.config)
            warnings.warn("ignored! this call has no effect when already running.")
            return

        # self.config.update(kwargs)
        connect_existing = False
        if self.config.host is not None and self.config.port is not None:
            connect_existing = True
        else:
            self.config.host = "127.0.0.1"
            self.config.port = util.free_port()

        if not connect_existing:
            logger.debug(
                "BROWSER EXECUTABLE PATH: %s", self.config.browser_executable_path
            )
            if not pathlib.Path(self.config.browser_executable_path).exists():
                raise FileNotFoundError(
                    (
                        """
                    ---------------------
                    Could not determine browser executable.
                    ---------------------
                    Make sure your browser is installed in the default location (path).
                    If you are sure about the browser executable, you can specify it using
                    the `browser_executable_path='{}` parameter."""
                    ).format(
                        "/path/to/browser/executable"
                        if is_posix
                        else "c:/path/to/your/browser.exe"
                    )
                )

        if getattr(self.config, "_extensions", None):  # noqa
            self.config.add_argument(
                "--load-extension=%s"
                % ",".join(str(_) for _ in self.config._extensions)
            )  # noqa

        exe = self.config.browser_executable_path
        params = self.config()
```

--------------------------------

### Initialize browser with custom options

Source: https://ultrafunkamsterdam.github.io/nodriver/nodriver/quickstart.html

Configures browser startup parameters directly within the start function, including headless mode, user data directories, and executable paths.

```python
from nodriver import *

browser = await start(
    headless=False,
    user_data_dir="/path/to/existing/profile",  # by specifying it, it won't be automatically cleaned up when finished
    browser_executable_path="/path/to/some/other/browser",
    browser_args=['--some-browser-arg=true', '--some-other-option'],
    lang="en-US"   # this could set iso-language-code in navigator, not recommended to change
)
tab = await browser.get('https://somewebsite.com')
```

--------------------------------

### get_categories()

Source: https://ultrafunkamsterdam.github.io/nodriver/nodriver/cdp/tracing.html

Gets supported tracing categories.

```APIDOC
## get_categories()

### Description
Gets supported tracing categories. This method is marked as EXPERIMENTAL.

### Returns
A list of supported tracing categories.

### Return Type
`Generator[Dict[str, Any], Dict[str, Any], List[str]]`
```

--------------------------------

### Basic Browser Automation with Nodriver

Source: https://ultrafunkamsterdam.github.io/nodriver/readme.html

Demonstrates starting a browser, navigating to URLs, taking screenshots, and managing multiple tabs.

```python
import asyncio
import nodriver as uc

async def main():
    browser = await uc.start()
    page = await browser.get('https://www.nowsecure.nl')

    await page.save_screenshot()
    await page.get_content()
    await page.scroll_down(150)
    elems = await page.select_all('*[src]')
    for elem in elems:
        await elem.flash()

    page2 = await browser.get('https://twitter.com', new_tab=True)
    page3 = await browser.get('https://github.com/ultrafunkamsterdam/nodriver', new_window=True)

    for p in (page, page2, page3):
       await p.bring_to_front()
       await p.scroll_down(200)
       await p   # wait for events to be processed
       await p.reload()
       if p != page3:
           await p.close()


if __name__ == '__main__':

    # since asyncio.run never worked (for me)
    uc.loop().run_until_complete(main())
```

--------------------------------

### Create browser context with proxy

Source: https://ultrafunkamsterdam.github.io/nodriver/nodriver/quickstart.html

Demonstrates how to create a browser context with a specific proxy server, allowing different proxies for different contexts.

```python
from nodriver import *
browser = await start()
proxied_tab = await browser.create_context(
    url: ...
    proxy_server = "socks5://myuser:mypass@myproxyhost.local"
    proxy_bypass_list = ["localhost"]
)
await proxied_tab.get('https://whatismyip.com')
```

--------------------------------

### get

Source: https://ultrafunkamsterdam.github.io/nodriver/_modules/nodriver/core/tab.html

Navigates the tab to a specified URL.

```APIDOC
## get(url="chrome://welcome", new_tab=False, new_window=False)

### Description
Navigates the current tab to the given URL. Handles waits and detects DOM events.

### Parameters
- **url** (str) - Optional - The URL to navigate to (default: "chrome://welcome")
- **new_tab** (bool) - Optional - Whether to open in a new tab (default: False)
- **new_window** (bool) - Optional - Whether to open in a new window (default: False)

### Returns
- **Page** - The current page object.
```

--------------------------------

### get_metadata

Source: https://ultrafunkamsterdam.github.io/nodriver/nodriver/cdp/indexed_db.html

Gets metadata of an object store.

```APIDOC
## get_metadata(database_name, object_store_name, security_origin=None, storage_key=None, storage_bucket=None)

### Description
Gets metadata of an object store.

### Parameters
- **database_name** (str) - Required
- **object_store_name** (str) - Required
- **security_origin** (Optional[str]) - Optional
- **storage_key** (Optional[str]) - Optional
- **storage_bucket** (Optional[StorageBucket]) - Optional

### Returns
A tuple containing (entriesCount, keyGeneratorValue).
```

--------------------------------

### CSS.startRuleUsageTracking

Source: https://ultrafunkamsterdam.github.io/nodriver/_modules/nodriver/cdp/css.html

Enables the selector recording.

```APIDOC
## CSS.startRuleUsageTracking

### Description
Enables the selector recording.
```

--------------------------------

### Page.getAppManifest

Source: https://ultrafunkamsterdam.github.io/nodriver/_modules/nodriver/cdp/page.html

Gets the processed manifest for the current document.

```APIDOC
## Page.getAppManifest

### Description
Gets the processed manifest for this current document. This API always waits for the manifest to be loaded. If manifestId is provided, and it does not match the manifest of the current document, this API errors out.

### Parameters
- **manifest_id** (string) - Optional
```

--------------------------------

### get_node_stack_traces

Source: https://ultrafunkamsterdam.github.io/nodriver/nodriver/cdp/dom.html

Gets stack traces associated with a Node.

```APIDOC
## get_node_stack_traces(node_id)

### Description
Gets stack traces associated with a Node. As of now, only provides stack trace for Node creation. This is an experimental method.

### Parameters
- **node_id** (NodeId) - Required - Id of the node to get stack traces for.

### Returns
- (Optional[StackTrace]) - Creation stack trace, if available.
```

--------------------------------

### get_playback_rate()

Source: https://ultrafunkamsterdam.github.io/nodriver/nodriver/cdp/animation.html

Gets the playback rate of the document timeline.

```APIDOC
## get_playback_rate()

### Description
Gets the playback rate of the document timeline.

### Return Type
`Generator[Dict[str, Any], Dict[str, Any], float]`
```

--------------------------------

### enable

Source: https://ultrafunkamsterdam.github.io/nodriver/nodriver/cdp/bluetooth_emulation.html

Enables the BluetoothEmulation domain.

```APIDOC
## enable(state, le_supported)

### Description
Enable the BluetoothEmulation domain.

### Parameters
- **state** (CentralState) - Required
- **le_supported** (bool) - Required
```

--------------------------------

### Tracing.start

Source: https://ultrafunkamsterdam.github.io/nodriver/_modules/nodriver/cdp/tracing.html

Starts trace events collection. This method allows configuring the tracing session with various parameters including categories, transfer modes, and specific configurations like Perfetto.

```APIDOC
## Tracing.start

### Description
Starts trace events collection. This method allows configuring the tracing session with various parameters including categories, transfer modes, and specific configurations like Perfetto.

### Parameters
- **categories** (string) - Optional - (DEPRECATED) (EXPERIMENTAL) Category/tag filter.
- **options** (string) - Optional - (DEPRECATED) (EXPERIMENTAL) Tracing options.
- **buffer_usage_reporting_interval** (number) - Optional - (EXPERIMENTAL) If set, the agent will issue bufferUsage events at this interval, specified in milliseconds.
- **transfer_mode** (string) - Optional - Whether to report trace events as series of dataCollected events or to save trace to a stream (defaults to 'ReportEvents').
- **stream_format** (StreamFormat) - Optional - Trace data format to use. This only applies when using 'ReturnAsStream' transfer mode (defaults to 'json').
- **stream_compression** (StreamCompression) - Optional - (EXPERIMENTAL) Compression format to use. This only applies when using 'ReturnAsStream' transfer mode (defaults to 'none').
- **trace_config** (TraceConfig) - Optional - Configuration for the trace.
- **perfetto_config** (string) - Optional - (EXPERIMENTAL) Base64-encoded serialized perfetto.protos.TraceConfig protobuf message.
- **tracing_backend** (TracingBackend) - Optional - (EXPERIMENTAL) Backend type (defaults to 'auto').
```

--------------------------------

### Animation Started Event

Source: https://ultrafunkamsterdam.github.io/nodriver/_modules/nodriver/cdp/animation.html

Dataclass representing the Animation.animationStarted event.

```python
[docs]
@event_class('Animation.animationStarted')
@dataclass
class AnimationStarted:
    '''
    Event for animation that has been started.
    '''
    #: Animation that was started.
    animation: Animation
```

--------------------------------

### Cast.startTabMirroring

Source: https://ultrafunkamsterdam.github.io/nodriver/_modules/nodriver/cdp/cast.html

Starts mirroring the current tab to the specified sink.

```APIDOC
## Cast.startTabMirroring

### Description
Starts mirroring the tab to the sink.

### Parameters
- **sinkName** (string) - Required - The name of the sink to mirror to.
```

--------------------------------

### Enable Performance Metrics

Source: https://ultrafunkamsterdam.github.io/nodriver/_modules/nodriver/cdp/performance.html

Starts the collection and reporting of performance metrics, with an optional time domain parameter.

```python
def enable(
        time_domain: typing.Optional[str] = None
    ) -> typing.Generator[T_JSON_DICT,T_JSON_DICT,None]:
    '''
    Enable collecting and reporting metrics.

    :param time_domain: *(Optional)* Time domain to use for collecting and reporting duration metrics.
    '''
    params: T_JSON_DICT = dict()
    if time_domain is not None:
        params['timeDomain'] = time_domain
    cmd_dict: T_JSON_DICT = {
        'method': 'Performance.enable',
        'params': params,
    }
    json = yield cmd_dict
```

--------------------------------

### get_app_manifest(manifest_id=None)

Source: https://ultrafunkamsterdam.github.io/nodriver/nodriver/cdp/page.html

Gets the processed manifest for the current document.

```APIDOC
## get_app_manifest

### Description
Gets the processed manifest for this current document. This API always waits for the manifest to be loaded.

### Parameters
- **manifest_id** (Optional[str]) - Optional
```

--------------------------------

### SystemInfo.getInfo

Source: https://ultrafunkamsterdam.github.io/nodriver/_modules/nodriver/cdp/system_info.html

Retrieves comprehensive information about the system, including GPU details, machine model, version, and the browser launch command line.

```APIDOC
## SystemInfo.getInfo

### Description
Returns information about the system, including GPU details, machine model, version, and the command line used to launch the browser.

### Returns
- **gpu** (GPUInfo) - Information about the GPUs on the system.
- **modelName** (string) - A platform-dependent description of the machine model.
- **modelVersion** (string) - A platform-dependent description of the machine version.
- **commandLine** (string) - The command line string used to launch the browser.
```

--------------------------------

### Get Certificate

Source: https://ultrafunkamsterdam.github.io/nodriver/_modules/nodriver/cdp/network.html

Retrieves the DER-encoded certificate for a given origin.

```python
def get_certificate(
        origin: str
    ) -> typing.Generator[T_JSON_DICT,T_JSON_DICT,typing.List[str]]:
    '''
    Returns the DER-encoded certificate.

    **EXPERIMENTAL**

    :param origin: Origin to get certificate for.
    :returns: 
    '''
    params: T_JSON_DICT = dict()
    params['origin'] = origin
    cmd_dict: T_JSON_DICT = {
        'method': 'Network.getCertificate',
        'params': params,
    }
    json = yield cmd_dict
    return [str(i) for i in json['tableNames']]
```

--------------------------------

### get_frame_resource_urls()

Source: https://ultrafunkamsterdam.github.io/nodriver/_modules/nodriver/core/tab.html

Gets the URLs of all resources within the frame tree.

```APIDOC
### Method
`async def get_frame_resource_urls(self) -> List[str]`

### Description
Returns a list of URLs for all resources found in the frame tree.
```

--------------------------------

### CSS.forceStartingStyle

Source: https://ultrafunkamsterdam.github.io/nodriver/_modules/nodriver/cdp/css.html

Ensures that the given node is in its starting-style state.

```APIDOC
## CSS.forceStartingStyle

### Description
Ensures that the given node is in its starting-style state.

### Parameters
- **node_id** (dom.NodeId) - Required - The element id for which to force the starting-style state.
- **forced** (bool) - Required - Boolean indicating if this is on or off.
```

--------------------------------

### Get Credentials

Source: https://ultrafunkamsterdam.github.io/nodriver/_modules/nodriver/cdp/web_authn.html

Retrieves all credentials stored in a virtual authenticator.

```python
def get_credentials(
        authenticator_id: AuthenticatorId
    ) -> typing.Generator[T_JSON_DICT,T_JSON_DICT,typing.List[Credential]]:
    '''
    Returns all the credentials stored in the given virtual authenticator.

    :param authenticator_id:
    :returns: 
    '''
    params: T_JSON_DICT = dict()
    params['authenticatorId'] = authenticator_id.to_json()
    cmd_dict: T_JSON_DICT = {
        'method': 'WebAuthn.getCredentials',
        'params': params,
    }
    json = yield cmd_dict
    return [Credential.from_json(i) for i in json['credentials']]
```

--------------------------------

### Get Stack Trace

Source: https://ultrafunkamsterdam.github.io/nodriver/_modules/nodriver/cdp/debugger.html

Retrieves a stack trace by its ID.

```python
def get_stack_trace(
        stack_trace_id: runtime.StackTraceId
    ) -> typing.Generator[T_JSON_DICT,T_JSON_DICT,runtime.StackTrace]:
    '''
    Returns stack trace with given ``stackTraceId``.

    **EXPERIMENTAL**

    :param stack_trace_id:
    :returns: 
    '''
    params: T_JSON_DICT = dict()
    params['stackTraceId'] = stack_trace_id.to_json()
    cmd_dict: T_JSON_DICT = {
        'method': 'Debugger.getStackTrace',
        'params': params,
    }
    json = yield cmd_dict
    return runtime.StackTrace.from_json(json['stackTrace'])
```

--------------------------------

### enable()

Source: https://ultrafunkamsterdam.github.io/nodriver/nodriver/cdp/dom_storage.html

Enables storage tracking, allowing storage events to be delivered to the client.

```APIDOC
## enable()

### Description
Enables storage tracking, allowing storage events to be delivered to the client.
```

--------------------------------

### find_chrome_executable(return_all=False)

Source: https://ultrafunkamsterdam.github.io/nodriver/_modules/nodriver/core/config.html

Locates the path to the installed browser executable on the system.

```APIDOC
## find_chrome_executable(return_all=False)

### Description
Searches the system PATH and common installation directories to find Chrome, Chromium, or related browser executables.

### Parameters
- **return_all** (bool) - Optional - If True, returns a list of all found candidates instead of just the first match.
```

--------------------------------

### start_violations_report(config)

Source: https://ultrafunkamsterdam.github.io/nodriver/nodriver/cdp/log.html

Starts violation reporting based on the provided configuration.

```APIDOC
## start_violations_report(config)

### Description
Start violation reporting.

### Parameters
- **config** (List[ViolationSetting]) - Required - Configuration for violations.

### Return Type
`Generator[Dict[str, Any], Dict[str, Any], None]`
```

--------------------------------

### BluetoothEmulation.addService

Source: https://ultrafunkamsterdam.github.io/nodriver/_modules/nodriver/cdp/bluetooth_emulation.html

Adds a service to the simulated central.

```APIDOC
## BluetoothEmulation.addService

### Description
Adds a service with the specified UUID to the simulated central.

### Parameters
- **address** (str) - The address of the peripheral.
- **service_uuid** (str) - The UUID of the service to add.

### Returns
- **serviceId** (str) - An identifier that uniquely represents this service.
```

--------------------------------

### API Usage Examples

Source: https://ultrafunkamsterdam.github.io/nodriver/readme.html

Common API patterns for interacting with elements, tabs, and browser navigation.

```python
elem.text
elem.text_all
elem.parent.parent.parent.attrs
anchor_elem.href and anchor_elem['href']
anchor_elem.href = 'someotherthing'; await anchor_elem.save()
elem.children[-1].children[0].children[4].parent.parent
await html5video_element.record_video()
await html5video_element('pause')
await html5video_element.apply('''(el) => el.currentTime = 0''')
tab = await browser.get(url, new_tab=True)
tab_win = await browser.get(url, new_window=True)
first = await tab.find('search text')
best = await tab.find('search text', best_match=True)
all_results = await tab.find_all('search text')
first_submit_button = await tab.select(selector='button[type=submit]')
inputs_in_form = await tab.select_all('form input')
```

--------------------------------

### track_computed_style_updates_for_node

Source: https://ultrafunkamsterdam.github.io/nodriver/_modules/nodriver/cdp/css.html

Starts tracking the given node for computed style updates.

```APIDOC
## CSS.trackComputedStyleUpdatesForNode

### Description
Starts tracking the given node for computed style updates. Whenever the computed style is updated for the node, it queues a computedStyleUpdated event. Passing a new node ID removes tracking from the previous node; passing undefined disables tracking.

### Parameters
- **node_id** (dom.NodeId) - Optional - The ID of the node to track.
```
Tokens:
Raw