Puppeteer Sharp

https://www.puppeteersharp.com/docs
Admin
Puppeteer Sharp is a .NET port of the official Node.JS Puppeteer API, used for automating browsers,...
Tokens:9,163
Snippets:122
Trust Score:7.7
Update:3 months ago
Show doc for...
Tokens:
Raw
### Full Example: Puppeteer Sharp with AOT and Custom Serialization

Source: https://www.puppeteersharp.com/docs/AOT.html

This example demonstrates launching a browser, navigating to a page, and using `EvaluateFunctionAsync` with a custom class, all within an AOT-compatible setup.

```csharp
class MainClass
{
    public static async Task Main(string[] args)
    {
        Puppeteer.ExtraJsonSerializerContext = DemoJsonSerializationContext.Default;
        var options = new LaunchOptions { Headless = true };

        var browserFetcher = new BrowserFetcher();
        await browserFetcher.DownloadAsync();

        await using var browser = await Puppeteer.LaunchAsync(options);
        await using var page = await browser.NewPageAsync();

        await page.GoToAsync("https://www.google.com");

        var result = await page.EvaluateFunctionAsync<TestClass>("test => test", new TestClass { Name = "Dario"});
    }
}

public class TestClass
{
    public string Name { get; set; }
}

[JsonSerializable(typeof(TestClass))]
public partial class DemoJsonSerializationContext : JsonSerializerContext
{}

```

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

### Combine Multiple Locator Configurations

Source: https://www.puppeteersharp.com/docs/Locators.html

Chain multiple configuration methods to precisely control locator behavior. This example sets timeout, visibility, enabled state, viewport scrolling, and bounding box stability.

```csharp
await page.Locator("button.submit")
    .SetTimeout(10000)
    .SetVisibility(VisibilityOption.Visible)
    .SetWaitForEnabled(true)
    .SetEnsureElementIsInTheViewport(true)
    .SetWaitForStableBoundingBox(true)
    .ClickAsync();
```

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

### Race Multiple Locators

Source: https://www.puppeteersharp.com/docs/Locators.html

Races multiple locators and resolves with the first one to find an element. This example clicks the first available button (accept or dismiss).

```csharp
await Locator.Race(
    page.Locator("button.accept"),
    page.Locator("button.dismiss")
).ClickAsync();
```

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

### Wait for and Get Page Title

Source: https://www.puppeteersharp.com/docs/Locators.html

Waits for the locator to get a value from the page, returned as a JSON-deserialized object. This example retrieves the page title as a string.

```csharp
var value = await page.LocatorFunction("() => document.title")
    .WaitAsync<string>();
```

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

### Get All Links from a Page

Source: https://www.puppeteersharp.com/docs/Page.EvaluateExpressionAsync.GetAllLinks.html

This snippet demonstrates how to fetch all hyperlink URLs from a given web page. It launches a browser, navigates to a URL, and then evaluates a JavaScript expression to collect all `href` attributes from `<a>` tags. Ensure you have PuppeteerSharp installed and the necessary browser binaries downloaded.

```csharp
using (var browser = await Puppeteer.LaunchAsync(options))
using (var page = await browser.NewPageAsync())
{
    await page.GoToAsync("http://www.google.com");
    var jsSelectAllAnchors = @"Array.from(document.querySelectorAll('a')).map(a => a.href);";
    var urls = await page.EvaluateExpressionAsync<string[]>(jsSelectAllAnchors);
    foreach (string url in urls)
    {
        Console.WriteLine($"Url: {url}");
    }
    Console.WriteLine("Press any key to continue...");
    Console.ReadLine();
}
```

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

### Map Locator Elements with JavaScript Function

Source: https://www.puppeteersharp.com/docs/Locators.html

Creates a new locator that maps the located element using a JavaScript function. This example retrieves the text content of elements.

```csharp
var text = await page.Locator("div.content")
    .Map("element => element.textContent")
    .WaitAsync<string>();
```

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

### WaitHandleAsync

Source: https://www.puppeteersharp.com/docs/Locators.html

Waits for the locator to get a handle from the page.

```APIDOC
## WaitHandleAsync

### Description
Waits for the locator to get a handle from the page.

### Method
`WaitHandleAsync`

### Request Example
```csharp
var handle = await page.Locator("button.submit").WaitHandleAsync();
```
```

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

### Wait for Element Handle

Source: https://www.puppeteersharp.com/docs/Locators.html

Waits for the locator to get a handle from the page.

```csharp
var handle = await page.Locator("button.submit").WaitHandleAsync();
```

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

### Interact with Elements in Frames using Locators

Source: https://www.puppeteersharp.com/docs/Locators.html

Locators can be used within frames to find and interact with elements. First, get a reference to the frame, then create a locator within that frame's context.

```csharp
var frame = page.MainFrame.ChildFrames[0];
await frame.Locator("button.submit").ClickAsync();
```

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

### WaitAsync<T>

Source: https://www.puppeteersharp.com/docs/Locators.html

Waits for the locator to get a value from the page and returns it as a JSON-deserialized object of type T.

```APIDOC
## WaitAsync<T>

### Description
Waits for the locator to get a value from the page, returned as a JSON-deserialized object.

### Method
`WaitAsync<T>`

### Parameters
- **T** (Type) - The type to deserialize the returned value into.

### Request Example
```csharp
var value = await page.LocatorFunction("() => document.title")
    .WaitAsync<string>();
```
```

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

### Get Inner Text of an Element

Source: https://www.puppeteersharp.com/docs/index.html

Retrieves the inner text content of a specific HTML element using its selector. This involves querying the element and then accessing its 'innerText' property.

```csharp
using var page = await browser.NewPageAsync();
await page.GoToAsync("https://example.com");
var pageHeaderHandle = await page.QuerySelectorAsync("h1");
var innerTextHandle = await pageHeaderHandle.GetPropertyAsync("innerText");
var innerText = await innerTextHandle.JsonValueAsync();
```

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

### Manually Configure Browser Sandbox Permissions

Source: https://www.puppeteersharp.com/docs/IssuesGeneratingPdfFiles.html

Execute the setup.exe with administrator privileges to manually configure sandbox permissions for the downloaded browser. This is a workaround if automatic configuration fails.

```powershell
cd <path-to-browser>
.\setup.exe --configure-browser-in-directory="<path-to-browser>"
```

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

### Taking a Screenshot of a Web Page

Source: https://www.puppeteersharp.com/docs/Page.ScreenshotAsync.html

This snippet demonstrates how to download the necessary browser revision, set up launch options, navigate to a URL, and take a screenshot, saving it to a specified file. Ensure BrowserFetcher is used to download the browser.

```csharp
using var browserFetcher = new BrowserFetcher();
await browserFetcher.DownloadAsync(BrowserFetcher.DefaultRevision);

var url = "https://www.somepage.com";
var file = ".\\somepage.jpg";

var launchOptions = new LaunchOptions()
{
    Headless = false
};

using (var browser = await Puppeteer.LaunchAsync(launchOptions))
using (var page = await browser.NewPageAsync())
{
    await page.GoToAsync(url);
    await page.ScreenshotAsync(file);
}
```

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

### Waiting for a Selector and Interacting

Source: https://www.puppeteersharp.com/docs/Page.WaitForSelectorAsync.Searching.html

This C# snippet demonstrates how to launch a browser, navigate to a page, type into a search box, wait for a specific selector to appear, and then click it. It's useful for scenarios where you need to ensure an element is present before interacting with it.

```csharp
using (var browser = await Puppeteer.LaunchAsync(options))
using (var page = await browser.NewPageAsync())
{
    await page.GoToAsync("https://developers.google.com/web/");
    // Type into search box.
    await page.TypeAsync("#searchbox input", "Headless Chrome");

    // Wait for suggest overlay to appear and click "show all results".
    var allResultsSelector = ".devsite-suggest-all-results";
    await page.WaitForSelectorAsync(allResultsSelector);
    await page.ClickAsync(allResultsSelector);

    // continue the operation
}
```

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

### Generate PDF

Source: https://www.puppeteersharp.com/docs/index.html

Launches a browser, navigates to a URL, and generates a PDF file of the page. The browser instance should be disposed of properly.

```csharp
using var browser = await Puppeteer.LaunchAsync(new LaunchOptions { Headless = true });
var page = await browser.NewPageAsync();
await page.GoToAsync("https://www.google.com");
await page.PdfAsync("output.pdf");
```

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

### WaitAsync with CancellationToken

Source: https://www.puppeteersharp.com/docs/Locators.html

Shows how to use CancellationToken with the WaitAsync method for locator actions, allowing for cancellation of waiting operations.

```csharp
await page.Locator("div.loaded").WaitAsync(new LocatorActionOptions
{
    CancellationToken = cts.Token
});
```

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

### Take Screenshot

Source: https://www.puppeteersharp.com/docs/index.html

Launches a browser, navigates to a URL, and takes a screenshot of the page. Ensure the browser is closed after use.

```csharp
using var browser = await Puppeteer.LaunchAsync(new LaunchOptions { Headless = true });
var page = await browser.NewPageAsync();
await page.GoToAsync("https://www.google.com");
await page.ScreenshotAsync("screenshot.png");
```

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

### Basic Click Action

Source: https://www.puppeteersharp.com/docs/LocatorActions.html

Clicks the located element after it passes all configured preconditions.

```csharp
await page.Locator("button.submit").ClickAsync();
```

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

### ClickAsync with CancellationToken

Source: https://www.puppeteersharp.com/docs/Locators.html

Demonstrates how to pass a CancellationToken to the ClickAsync method of a locator to set a timeout for the click operation.

```csharp
using var cts = new CancellationTokenSource(TimeSpan.FromSeconds(5));

await page.Locator("button.submit").ClickAsync(new LocatorClickOptions
{
    CancellationToken = cts.Token
});
```

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

### Configuring Locator Preconditions

Source: https://www.puppeteersharp.com/docs/LocatorActions.html

Configures specific preconditions for a locator before performing an action, such as waiting for stability, enabled state, or viewport visibility.

```csharp
await page.Locator("button.animated")
    .SetWaitForStableBoundingBox(true)  // wait for animation to finish
    .SetWaitForEnabled(true)             // wait for button to be enabled
    .SetEnsureElementIsInTheViewport(true) // scroll into view
    .ClickAsync();
```

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

### Create LoggerFactory for Console Logging

Source: https://www.puppeteersharp.com/docs/LogCDPCommunication.html

This snippet shows how to create an ILoggerFactory using Microsoft.Extensions.Logging to log CDP messages to the console. The ConsoleLoggerFormat is set to Systemd for structured logging. Ensure the Microsoft.Extensions.Logging.Console NuGet package is added.

```csharp
private static ILoggerFactory GetLoggerFactory()
{
    var loggerFactory = Microsoft.Extensions.Logging.LoggerFactory.Create(builder =>
    {
        builder
            .AddConsole(options => options.Format = ConsoleLoggerFormat.Systemd)
            .SetMinimumLevel(LogLevel.Trace);
    });

    return loggerFactory;
}
```

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

### Create LoggerFactory for Serilog File Logging

Source: https://www.puppeteersharp.com/docs/LogCDPCommunication.html

This snippet demonstrates how to create an ILoggerFactory configured with Serilog to log CDP messages to a file. Ensure the Serilog.Extensions.Logging.File NuGet package is added.

```csharp
private static ILoggerFactory GetLoggerFactory(string file)
{
    var factory = new LoggerFactory();
    var filter = new FilterLoggerSettings
    {
        { "Connection", LogLevel.Trace }
    };

    factory.WithFilter(filter).AddFile(file, LogLevel.Trace);

    return factory;
}
```

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

### Use Locators to Interact with Elements

Source: https://www.puppeteersharp.com/docs/index.html

Demonstrates using locators for robust element selection with auto-retry and auto-wait capabilities. Useful for clicking buttons and filling input fields.

```csharp
using var browser = await Puppeteer.LaunchAsync(new LaunchOptions { Headless = true });
var page = await browser.NewPageAsync();
await page.GoToAsync("https://example.com");

// Click a button with auto-wait
await page.Locator("button.submit").ClickAsync();

// Fill an input
await page.Locator("input[name='email']").FillAsync("user@example.com");
```

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

### Launch Puppeteer with Serilog File Logger

Source: https://www.puppeteersharp.com/docs/LogCDPCommunication.html

Integrates the Serilog file logger created previously into Puppeteer.LaunchAsync. This allows CDP messages to be written to the specified log file.

```csharp
using (var browser = await Puppeteer.LaunchAsync(browserOptions, GetLoggerFactory(fileName)))
{
    //Some code
}
```

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

### Launch Browser from Custom Executable Path

Source: https://www.puppeteersharp.com/docs/ReuseChrome.html

Launch PuppeteerSharp using LaunchOptions, setting the ExecutablePath to the downloaded Chrome's location. This allows reusing a previously downloaded Chrome instance.

```csharp
var options = new LaunchOptions { Headless = true, ExecutablePath = installedBrowser.GetExecutablePath() };

await using var browser = await Puppeteer.LaunchAsync(options);
await using var page = await browser.NewPageAsync();
await page.GoToAsync("about:blank");
```

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

### Configure Locator Visibility

Source: https://www.puppeteersharp.com/docs/Locators.html

Specify whether to wait for an element to be visible or hidden before performing an action. This is useful for handling dynamic content loading.

```csharp
// Wait for element to be visible before clicking
await page.Locator("button.submit")
    .SetVisibility(VisibilityOption.Visible)
    .ClickAsync();

// Wait for a loading spinner to disappear
await page.Locator(".spinner")
    .SetVisibility(VisibilityOption.Hidden)
    .WaitAsync();
```

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

### Download and Use Specific Chrome Versions

Source: https://www.puppeteersharp.com/docs/DownloadFetcher.Download.html

Use BrowserFetcher to download specific Chrome versions by their version number. Then, launch PuppeteerSharp using the downloaded executable path to perform browser automation tasks.

```csharp
Console.WriteLine("Downloading browsers");

var browserFetcher = new BrowserFetcher(SupportedBrowser.Chrome);
var chrome118 = await browserFetcher.DownloadAsync("118.0.5993.70");
var chrome119 = await browserFetcher.DownloadAsync("119.0.5997.0");

Console.WriteLine("Navigating");
await using (var browser = await Puppeteer.LaunchAsync(new()
{
    ExecutablePath = chrome118.GetExecutablePath(),
}))
{
    await using var page = await browser.NewPageAsync();
    await page.GoToAsync("https://www.whatismybrowser.com/");

    Console.WriteLine("Generating PDF");
    await page.PdfAsync(Path.Combine(Directory.GetCurrentDirectory(), "118.pdf"));

    Console.WriteLine("Export completed");
}

await using (var browser = await Puppeteer.LaunchAsync(new()
{
    ExecutablePath = chrome119.GetExecutablePath(),
}))
{
    await using var page = await browser.NewPageAsync();
    await page.GoToAsync("https://www.whatismybrowser.com/");

    Console.WriteLine("Generating PDF");
    await page.PdfAsync(Path.Combine(Directory.GetCurrentDirectory(), "119.pdf"));

    Console.WriteLine("Export completed");
}
```

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

### ClickAsync

Source: https://www.puppeteersharp.com/docs/LocatorActions.html

Clicks the located element. The locator waits for the element to pass all configured preconditions before clicking.

```APIDOC
## ClickAsync

### Description
Clicks the located element. The locator waits for the element to pass all configured preconditions before clicking.

### Method
`ClickAsync`

### Parameters
#### Request Body
- **Options** (`LocatorClickOptions`) - Optional - Options for the click action.
  - **Button** (`MouseButton`) - Optional - Mouse button to use. Defaults to `MouseButton.Left`.
  - **Count** (`int`) - Optional - Number of clicks (e.g., 2 for double-click). Defaults to `1`.
  - **Delay** (`int`) - Optional - Time in milliseconds between mousedown and mouseup. Defaults to `0`.
  - **OffSet** (`Offset?`) - Optional - Click offset relative to the element's padding box. Defaults to `null`.
  - **CancellationToken** (`CancellationToken`) - Optional - Token to cancel the action. Defaults to `default`.

### Request Example
**Double-click:**
```csharp
await page.Locator("div.editable").ClickAsync(new LocatorClickOptions
{
    Count = 2
});
```

**Right-click:**
```csharp
await page.Locator("div.context-menu-target").ClickAsync(new LocatorClickOptions
{
    Button = MouseButton.Right
});
```

**Click with offset:**
```csharp
await page.Locator("canvas").ClickAsync(new LocatorClickOptions
{
    OffSet = new Offset { X = 100, Y = 50 }
});
```

**Slow click (with delay):**
```csharp
await page.Locator("button.submit").ClickAsync(new LocatorClickOptions
{
    Delay = 100
});
```

### Response
This method does not return a value.
```

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

### Connect to Remote Browser

Source: https://www.puppeteersharp.com/docs/index.html

Connects to an already running browser instance using its WebSocket endpoint. Requires a valid browser endpoint URL and potentially an API key.

```csharp
var options = new ConnectOptions()
{
    BrowserWSEndpoint = $"wss://www.externalbrowser.io?token={apikey}"
};

var url = "https://www.google.com/";

using var browser = await Puppeteer.ConnectAsync(options);
using var page = await browser.NewPageAsync();
await page.GoToAsync(url);
await page.PdfAsync("output.pdf");
```

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

### Inject HTML Content

Source: https://www.puppeteersharp.com/docs/index.html

Sets the HTML content of a page directly and then optionally generates a PDF. Useful for creating pages dynamically.

```csharp
using var page = await browser.NewPageAsync();
await page.SetContentAsync("<div>My Receipt</div>");
var result = await page.GetContentAsync();
await page.PdfAsync("output.pdf");
```

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

### Launch Puppeteer with Console Logger

Source: https://www.puppeteersharp.com/docs/LogCDPCommunication.html

Integrates the console logger created previously into Puppeteer.LaunchAsync. This directs CDP messages to the console output.

```csharp
using (var browser = await Puppeteer.LaunchAsync(browserOptions, GetLoggerFactory()))
{
    //Some code
}
```

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

### Create a custom JsonSerializerContext

Source: https://www.puppeteersharp.com/docs/AOT.html

Create a partial class that inherits from `JsonSerializerContext` and is attributed with `JsonSerializable` for the custom class. This context is required for serializing custom objects.

```csharp
[JsonSerializable(typeof(TestClass))]
public partial class DemoJsonSerializationContext : JsonSerializerContext
{}

```

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

### Specify Download Path for BrowserFetcher

Source: https://www.puppeteersharp.com/docs/ReuseChrome.html

Use BrowserFetcherOptions to set a custom download path for Chrome. This ensures Chrome is downloaded to your specified location instead of the default.

```csharp
var downloadPath = "/Users/dario/chrome";
var browserFetcherOptions = new BrowserFetcherOptions { Path = downloadPath };
var browserFetcher = new BrowserFetcher(browserFetcherOptions);
var installedBrowser = await browserFetcher.DownloadAsync();
```

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

### Configure Locator Enabled State

Source: https://www.puppeteersharp.com/docs/Locators.html

Set whether to wait for the element to be enabled before acting. The default is `true`, ensuring interactions only happen with active elements.

```csharp
await page.Locator("button.submit")
    .SetWaitForEnabled(true)
    .ClickAsync();
```

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

### WaitAsync

Source: https://www.puppeteersharp.com/docs/Locators.html

Waits for the locator to locate an element matching the configured preconditions.

```APIDOC
## WaitAsync

### Description
Waits for the locator to locate an element matching the configured preconditions.

### Method
`WaitAsync`

### Request Example
```csharp
// Wait for an element to appear
await page.Locator("div.loaded").WaitAsync();
```
```

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

### Configure Locator Timeout

Source: https://www.puppeteersharp.com/docs/Locators.html

Set a custom timeout in milliseconds for locator actions. The default timeout is 30 seconds.

```csharp
await page.Locator("button.submit")
    .SetTimeout(5000)
    .ClickAsync();
```

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

### Wait for Element to Appear

Source: https://www.puppeteersharp.com/docs/Locators.html

Waits for the locator to locate an element matching the configured preconditions.

```csharp
// Wait for an element to appear
await page.Locator("div.loaded").WaitAsync();
```

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

### Create Function Locator

Source: https://www.puppeteersharp.com/docs/Locators.html

Use `Page.LocatorFunction()` to create a locator that evaluates a JavaScript function. This is useful for more complex element selection logic.

```csharp
var locator = page.LocatorFunction("() => document.querySelector('button')");
await locator.ClickAsync();
```

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

### ClickAsync

Source: https://www.puppeteersharp.com/docs/Locators.html

Clicks the located element. Options for button, count, delay, and offset can be provided.

```APIDOC
## ClickAsync

### Description
Clicks the located element.

### Method
`ClickAsync`

### Parameters
See Locator Actions for click options (button, count, delay, offset).

### Request Example
```csharp
await page.Locator("button.submit").ClickAsync();
```
```

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

### Launch Chrome with Extension Loaded

Source: https://www.puppeteersharp.com/docs/ChromeExtension.html

Use PuppeteerSharp to launch a Chrome browser instance with a specific Chrome extension loaded. This is essential for testing extension functionality.

```csharp
using var browserFetcher = new BrowserFetcher();
await browserFetcher.DownloadAsync(BrowserFetcher.DefaultRevision);

var pathToExtension = "path/to/extension";
var launchOptions = new LaunchOptions()
{
    Headless = false,
    Args = new []
    {
        $"--disable-extensions-except=\"{pathToExtension}\"",
        $"--load-extension=\"{pathToExtension}\""
    }
};

using (var browser = await Puppeteer.LaunchAsync(launchOptions))
using (var page = await browser.NewPageAsync())
{
    // test your extension here
}
```

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

### Configure Locator Bounding Box Stability

Source: https://www.puppeteersharp.com/docs/Locators.html

Set whether to wait for the element's bounding box to stabilize before acting. The default is `true`, preventing interactions with elements that are still animating or repositioning.

```csharp
await page.Locator("button.submit")
    .SetWaitForStableBoundingBox(true)
    .ClickAsync();
```

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

### Create CSS Selector Locator

Source: https://www.puppeteersharp.com/docs/Locators.html

Use `Page.Locator()` with a CSS selector to create a locator. This locator will be used to find and interact with the specified element.

```csharp
var locator = page.Locator("button.submit");
await locator.ClickAsync();
```

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

### Check Sandbox Permissions After Browser Download

Source: https://www.puppeteersharp.com/docs/IssuesGeneratingPdfFiles.html

Verify if PuppeteerSharp successfully applied sandbox permissions after downloading the browser. This is crucial for PDF generation on servers.

```csharp
var browserFetcher = new BrowserFetcher();
var installedBrowser = await browserFetcher.DownloadAsync(BrowserFetcher.);

if (!installedBrowser.PermissionsFixed)
{
    Console.WriteLine("Sandbox permissions were not applied. You need to run your application as an administrator.");
    return;
}
```

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

### Wait For Selector

Source: https://www.puppeteersharp.com/docs/index.html

Waits for a specific DOM element to appear in the page before proceeding. This is crucial for single-page applications or pages with dynamic content.

```csharp
using var page = await browser.NewPageAsync();
await page.GoToAsync("http://www.spapage.com");
await page.WaitForSelectorAsync("div.main-content");
await page.PdfAsync("output.pdf");
```

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

### Evaluate JavaScript to Extract Links and Map to .NET Objects

Source: https://www.puppeteersharp.com/docs/Page.EvaluateFunctionAsync.ComplexJSObjects.html

Executes JavaScript to select link elements, extract their titles and URLs, and returns them as an array of .NET objects. Ensure the JavaScript return type matches the generic type parameter of EvaluateFunctionAsync.

```csharp
using (var browser = await Puppeteer.LaunchAsync(options))
using (var page = await browser.NewPageAsync())
{
    await page.GoToAsync("https://news.ycombinator.com/");
    Console.WriteLine("Get all urls from page");
    var jsCode = @"() => {
const selectors = Array.from(document.querySelectorAll('a[class=""storylink""]'));
return selectors.map( t=> {return { title: t.innerHTML, url: t.href}});    }";
    var results = await page.EvaluateFunctionAsync<Data[]>(jsCode);
    foreach (var result in results)
    {
        Console.WriteLine(result.ToString());
    }
    Console.WriteLine("Press any key to continue...");
    Console.ReadLine();
}
```

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

### Map

Source: https://www.puppeteersharp.com/docs/Locators.html

Creates a new locator that maps the located element using a JavaScript function.

```APIDOC
## Map

### Description
Creates a new locator that maps the located element using a JavaScript function.

### Method
`Map`

### Parameters
- **mapFn** (string) - A JavaScript function that transforms the element.

### Request Example
```csharp
var text = await page.Locator("div.content")
    .Map("element => element.textContent")
    .WaitAsync<string>();
```
```

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

### FillAsync

Source: https://www.puppeteersharp.com/docs/LocatorActions.html

Fills the located element with a value. Automatically detects the element type and handles it appropriately.

```APIDOC
## FillAsync

### Description
Fills the located element with a value. Automatically detects the element type and handles it appropriately:
  * **`<input>`**: Focuses, clears, and types the value.
  * **`<textarea>`**: Focuses, clears, and types the value.
  * **`<select>`**: Selects the option with the matching value.
  * **`contenteditable`**: Focuses, clears, and types the value.

### Method
`FillAsync`

### Parameters
#### Path Parameters
- **value** (string) - Required - The value to fill into the element.

#### Request Body
- **Options** (`LocatorActionOptions`) - Optional - Options for the fill action.
  - **CancellationToken** (`CancellationToken`) - Optional - Token to cancel the action. Defaults to `default`.

### Response
This method does not return a value.
```

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

### Locator.Race

Source: https://www.puppeteersharp.com/docs/Locators.html

Races multiple locators and resolves with the first one to find an element.

```APIDOC
## Locator.Race

### Description
Races multiple locators and resolves with the first one to find an element.

### Method
`Locator.Race`

### Parameters
- **locators** (params Locator[]) - An array of locators to race.

### Request Example
```csharp
await Locator.Race(
    page.Locator("button.accept"),
    page.Locator("button.dismiss")
).ClickAsync();
```
```

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

### Log Network Requests

Source: https://www.puppeteersharp.com/docs/Page.Request.html

Use the Page.Request event to capture and log details of outgoing network requests, including method, URL, and headers. This is useful for debugging or monitoring network activity.

```csharp
using var browser = await Puppeteer.LaunchAsync(new () { Headless = true });
var page = await browser.NewPageAsync();
page.Request += (sender, e) =>
{
    Console.WriteLine($"Request: {e.Request.Method} {e.Request.Url}");
    foreach (var header in e.Request.Headers)
    {
        Console.WriteLine($"{header.Key}: {header.Value}");
    }
};
await page.GoToAsync("https://example.com");

```

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

### Fill Input or Select Element

Source: https://www.puppeteersharp.com/docs/Locators.html

Fills the located element with a value. Works with input, textarea, select, and contenteditable elements.

```csharp
// Fill a text input
await page.Locator("input[name='email']").FillAsync("user@example.com");

// Select an option
await page.Locator("select#country").FillAsync("US");
```

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

### Right Click Action

Source: https://www.puppeteersharp.com/docs/LocatorActions.html

Performs a right-click on the located element. Useful for triggering context menus.

```csharp
await page.Locator("div.context-menu-target").ClickAsync(new LocatorClickOptions
{
    Button = MouseButton.Right
});
```

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

### Click with Offset

Source: https://www.puppeteersharp.com/docs/LocatorActions.html

Clicks the located element at a specific offset relative to its padding box. Useful for precise interactions.

```csharp
await page.Locator("canvas").ClickAsync(new LocatorClickOptions
{
    OffSet = new Offset { X = 100, Y = 50 }
});
```

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

### Configure Locator Viewport Scrolling

Source: https://www.puppeteersharp.com/docs/Locators.html

Enable or disable automatic scrolling to ensure the element is within the viewport before interaction. The default is `true`.

```csharp
await page.Locator("button.submit")
    .SetEnsureElementIsInTheViewport(true)
    .ClickAsync();
```

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

### Change Viewport Before Screenshot

Source: https://www.puppeteersharp.com/docs/index.html

Sets the viewport dimensions before taking a screenshot. This affects the resolution and layout of the captured image.

```csharp
await page.SetViewportAsync(new ViewPortOptions
{
    Width = 500,
    Height = 500
});
```

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

### Filter Locators with JavaScript Predicate

Source: https://www.puppeteersharp.com/docs/Locators.html

Creates a new locator that filters elements using a JavaScript predicate. If the predicate returns false, the locator retries.

```csharp
await page.Locator("button")
    .Filter("element => element.textContent === 'Submit'")
    .ClickAsync();
```

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

### Define a custom class for serialization

Source: https://www.puppeteersharp.com/docs/AOT.html

Define a custom class that will be passed to or from an `Evaluate` function. This class needs to be known to the serialization context.

```csharp
public class TestClass
{
    public string Name { get; set; }
}

```

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

### Wait for a simple JavaScript expression using WaitForExpressionAsync

Source: https://www.puppeteersharp.com/docs/Page.WaitForFunctionAsync.html

Use `WaitForExpressionAsync` when you need to wait for a simple JavaScript expression to evaluate to true. This is useful for checking conditions that cannot be met by simply waiting for a selector.

```csharp
using (var browser = await Puppeteer.LaunchAsync(options))
using (var page = await browser.NewPageAsync())
{
    await page.GoToAsync("https://www.somepage.com");
    await Page.WaitForExpressionAsync("document.queryselector('#status_info').innerText.match('^Showing ([1-9][0-9]*?) to ([1-9][0-9]*?)') of ([1-9][0-9]*?) entries') != null");
}
```

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

### Slow Click with Delay

Source: https://www.puppeteersharp.com/docs/LocatorActions.html

Performs a click with a specified delay between the mousedown and mouseup events. Useful for simulating slower user interactions.

```csharp
await page.Locator("button.submit").ClickAsync(new LocatorClickOptions
{
    Delay = 100
});
```

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

### Scroll Element to a Position

Source: https://www.puppeteersharp.com/docs/Locators.html

Scrolls the located element. See Locator Actions for scroll options.

```csharp
await page.Locator("div.scrollable").ScrollAsync(new LocatorScrollOptions
{
    ScrollTop = 500
});
```

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

### Set Puppeteer Sharp's serialization context

Source: https://www.puppeteersharp.com/docs/AOT.html

Set the `Puppeteer.ExtraJsonSerializerContext` to your custom context before launching the browser. This ensures custom objects are correctly serialized and deserialized.

```csharp
Puppeteer.ExtraJsonSerializerContext = DemoJsonSerializationContext.Default;

```

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

### Hover Action

Source: https://www.puppeteersharp.com/docs/LocatorActions.html

Hovers over the located element. This is useful for triggering hover states, tooltips, or dropdown menus.

```csharp
await page.Locator("button.submit").HoverAsync();
```

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

### Wait for a complex JavaScript expression using WaitForFunctionAsync

Source: https://www.puppeteersharp.com/docs/Page.WaitForFunctionAsync.html

When dealing with more complex JavaScript logic, wrap the expression in a function and use `WaitForFunctionAsync`. This allows for more intricate condition checking before proceeding.

```csharp
var waitTask = Page.WaitForFunctionAsync(@"() =>
{
    return document.queryselector('#status_info').innerText.match('^Showing ([1-9][0-9]*?) to ([1-9][0-9]*?)') of ([1-9][0-9]*?) entries') != null;
");
```

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

### Fill Input/Textarea

Source: https://www.puppeteersharp.com/docs/LocatorActions.html

Fills the located element with a specified value. This method handles input, textarea, and contenteditable elements by focusing, clearing, and typing.

```csharp
await page.Locator("input[name='email']").FillAsync("user@example.com");
```

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

### Filter

Source: https://www.puppeteersharp.com/docs/Locators.html

Creates a new locator that filters elements using a JavaScript predicate. The locator retries if the predicate returns false.

```APIDOC
## Filter

### Description
Creates a new locator that filters elements using a JavaScript predicate. If the predicate returns false, the locator retries.

### Method
`Filter`

### Parameters
- **predicate** (string) - A JavaScript function that returns a boolean.

### Request Example
```csharp
await page.Locator("button")
    .Filter("element => element.textContent === 'Submit'")
    .ClickAsync();
```
```

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

### ScrollAsync

Source: https://www.puppeteersharp.com/docs/Locators.html

Scrolls the located element. Specific scroll options can be provided.

```APIDOC
## ScrollAsync

### Description
Scrolls the located element.

### Method
`ScrollAsync`

### Parameters
- **options** (LocatorScrollOptions) - Options for scrolling, such as `ScrollTop`.

### Request Example
```csharp
await page.Locator("div.scrollable").ScrollAsync(new LocatorScrollOptions
{
    ScrollTop = 500
});
```

See Locator Actions for scroll options.
```

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

### Double Click Action

Source: https://www.puppeteersharp.com/docs/LocatorActions.html

Performs a double-click on the located element. Use this for elements that require two clicks to activate.

```csharp
await page.Locator("div.editable").ClickAsync(new LocatorClickOptions
{
    Count = 2
});
```

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

### C# Class for Data Mapping

Source: https://www.puppeteersharp.com/docs/Page.EvaluateFunctionAsync.ComplexJSObjects.html

Defines a C# class to represent the structure of the JavaScript object that will be returned.

```csharp
public class Data
{
    public string Title { get; set; }
    public string Url { get; set; }
}
```

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

### HoverAsync

Source: https://www.puppeteersharp.com/docs/LocatorActions.html

Hovers over the located element. Useful for triggering hover states, tooltips, or dropdown menus.

```APIDOC
## HoverAsync

### Description
Hovers over the located element. Useful for triggering hover states, tooltips, or dropdown menus.

### Method
`HoverAsync`

### Parameters
#### Request Body
- **Options** (`LocatorActionOptions`) - Optional - Options for the hover action.
  - **CancellationToken** (`CancellationToken`) - Optional - Token to cancel the action. Defaults to `default`.

### Response
This method does not return a value.
```

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

### Evaluate JavaScript Expressions

Source: https://www.puppeteersharp.com/docs/index.html

Executes JavaScript code within the browser context. Supports evaluating simple expressions or complex functions with arguments.

```csharp
using var page = await browser.NewPageAsync();
var seven = await page.EvaluateExpressionAsync<int>("() => 4 + 3");
var someObject = await page.EvaluateFunctionAsync<dynamic>("(value) => ({a: value})", 5);
Console.WriteLine(someObject.a);
```

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

### ScrollAsync

Source: https://www.puppeteersharp.com/docs/LocatorActions.html

Scrolls the located element to a specific position.

```APIDOC
## ScrollAsync

### Description
Scrolls the located element to a specific position.

### Method
`ScrollAsync`

### Parameters
#### Request Body
- **Options** (`LocatorScrollOptions`) - Optional - Options for the scroll action.
  - **ScrollTop** (`decimal?`) - Optional - Vertical scroll position. Defaults to `null`.
  - **ScrollLeft** (`decimal?`) - Optional - Horizontal scroll position. Defaults to `null`.
  - **CancellationToken** (`CancellationToken`) - Optional - Token to cancel the action. Defaults to `default`.

### Request Example
```csharp
await page.Locator("div.scrollable").ScrollAsync(new LocatorScrollOptions
{
    ScrollTop = 500,
    ScrollLeft = 0
});
```

### Response
This method does not return a value.
```

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

### FillAsync

Source: https://www.puppeteersharp.com/docs/Locators.html

Fills the located element with a value. This method is suitable for input, textarea, select, and contenteditable elements.

```APIDOC
## FillAsync

### Description
Fills the located element with a value. Works with `<input>`, `<textarea>`, `<select>`, and `contenteditable` elements.

### Method
`FillAsync`

### Parameters
- **value** (string) - The value to fill the element with.

### Request Example
```csharp
// Fill a text input
await page.Locator("input[name='email']").FillAsync("user@example.com");

// Select an option
await page.Locator("select#country").FillAsync("US");
```
```

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

### Scroll to Position

Source: https://www.puppeteersharp.com/docs/LocatorActions.html

Scrolls the located element to a specific vertical and horizontal position. Use this for elements with scrollable content.

```csharp
await page.Locator("div.scrollable").ScrollAsync(new LocatorScrollOptions
{
    ScrollTop = 500,
    ScrollLeft = 0
});
```

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

### Wait For Function

Source: https://www.puppeteersharp.com/docs/index.html

Waits until a JavaScript function evaluates to a truthy value. This is useful for waiting on custom conditions or asynchronous operations within the page.

```csharp
using var page = await browser.NewPageAsync();
await page.GoToAsync("http://www.spapage.com");
var watchDog = page.WaitForFunctionAsync("() => window.innerWidth < 100");
await page.SetViewportAsync(new ViewPortOptions { Width = 50, Height = 50 });
await watchDog;
```
Tokens:
Raw