Playwright

https://playwright.dev/dotnet/
Admin
Playwright is a cross-browser automation library that enables reliable end-to-end testing for web...
Tokens:425,758
Snippets:3,558
Trust Score:9.9
Update:2 weeks ago
Show doc for...
Tokens:
Raw
### ExampleTest: verify homepage has Get Started link

Source: https://playwright.dev/dotnet/docs/webview2

Example test that inherits from WebView2Test. It navigates to https://playwright.dev and asserts that the 'Get Started' text is visible using Playwright's Expect API.

```csharp
using Microsoft.Playwright;  

using Microsoft.Playwright.Xunit;  

  

namespace PlaywrightTests;  

  

public class ExampleTest : WebView2Test  

{  

    [Fact]  

    public async Task HomepageHasPlaywrightInTitleAndGetStartedLinkLinkingtoTheIntroPage()  

    {  

        await Page.GotoAsync("https://playwright.dev");  

        var getStarted = Page.GetByText("Get Started");  

        await Expect(getStarted).ToBeVisibleAsync();  

    }  

}  
```

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

### Record using custom setup with Page.PauseAsync()

Source: https://playwright.dev/dotnet/docs/codegen

Use this C# example to start Playwright codegen with a custom browser context setup. It launches Chromium in headed mode, creates a context with any options, and calls Page.PauseAsync() to open the codegen controls window. The example includes a RouteAsync() call to demonstrate non-standard setup.

```csharp
using Microsoft.Playwright;  

  
using var playwright = await Playwright.CreateAsync();  
var chromium = playwright.Chromium;  
// Make sure to run headed.  
var browser = await chromium.LaunchAsync(new() { Headless = false });  

// Setup context however you like.  
var context = await browser.NewContextAsync(); // Pass any options  
await context.RouteAsync("**/*", route => route.ContinueAsync());  

// Pause the page, and start recording manually.  
var page = await context.NewPageAsync();  
await page.PauseAsync();  
```

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

### Install Playwright with dependencies

Source: https://playwright.dev/dotnet/docs/ci

Build the project and install Playwright browsers with dependencies using the CLI. This is step 2 of the CI setup.

```bash
dotnet build  

pwsh bin/Debug/netX/playwright.ps1 install --with-deps  

```

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

### NUnit trace on failure

Source: https://playwright.dev/dotnet/docs/trace-viewer

NUnit example that starts tracing in SetUp and stops it in TearDown, saving a trace zip only when the test fails. Uses Context.Tracing.StartAsync and StopAsync with a conditional path.

```csharp
namespace PlaywrightTests;  

  
[Parallelizable(ParallelScope.Self)]  

[TestFixture]  

public class ExampleTest : PageTest  
{  
    [SetUp]  
    public async Task Setup()  
    {  
        await Context.Tracing.StartAsync(new()  
        {  
            Title = $"{TestContext.CurrentContext.Test.ClassName}.{TestContext.CurrentContext.Test.Name}",  
            Screenshots = true,  
            Snapshots = true,  
            Sources = true  
        });  
    }  

    [TearDown]  
    public async Task TearDown()  
    {  
        var failed = TestContext.CurrentContext.Result.Outcome == NUnit.Framework.Interfaces.ResultState.Error  
            || TestContext.CurrentContext.Result.Outcome == NUnit.Framework.Interfaces.ResultState.Failure;  

        await Context.Tracing.StopAsync(new()  
        {  
            Path = failed ? Path.Combine(  
                TestContext.CurrentContext.WorkDirectory,  
                "playwright-traces",  
                $"{TestContext.CurrentContext.Test.ClassName}.{TestContext.CurrentContext.Test.Name}.zip"  
            ) : null,  
        });  
    }  

    [Test]  
    public async Task GetStartedLink()  
    {  
        // ..  
    }  
}  

```

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

### Create CDPSession and use CDP protocol methods

Source: https://playwright.dev/dotnet/docs/api/class-cdpsession

Shows how to create a CDPSession, enable a protocol domain, subscribe to an event, and send protocol methods with parameters. The example uses the Animation domain to get and set the playback rate.

```csharp
var client = await Page.Context.NewCDPSessionAsync(Page);  

await client.SendAsync("Runtime.enable");  

client.Event("Animation.animationCreated").OnEvent += (_, _) => Console.WriteLine("Animation created!");  

var response = await client.SendAsync("Animation.getPlaybackRate");  

var playbackRate = response.Value.GetProperty("playbackRate").GetDouble();  

Console.WriteLine("playback rate is " + playbackRate);  

await client.SendAsync("Animation.setPlaybackRate", new() { { "playbackRate", playbackRate / 2 } });  

```

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

### Capture a credential and save it to a file

Source: https://playwright.dev/dotnet/docs/api/class-credentials

In a setup test, installs the virtual authenticator, lets the app register a passkey, then reads back the registered credential (including the private key) and serializes it to a JSON file for later reuse.

```csharp
// setup test: let the app register a passkey, then save it.  
var context = await browser.NewContextAsync();  
await context.Credentials.InstallAsync();  

var page = await context.NewPageAsync();  
await page.GotoAsync("https://example.com/register");  
await page.GetByRole(AriaRole.Button, new() { Name = "Create a passkey" }).ClickAsync();  

// Read back the passkey the page registered — it includes the private key.  
var credentials = await context.Credentials.GetAsync(new() { RpId = "example.com" });  
File.WriteAllText("playwright/.auth/passkey.json", JsonSerializer.Serialize(credentials[0]));
```

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

### InstallAsync: Install virtual WebAuthn authenticator

Source: https://playwright.dev/dotnet/docs/api/class-credentials

Installs the virtual WebAuthn authenticator into the context, overriding navigator.credentials.create() and get() in all current and future pages. Call before the page first touches navigator.credentials. Required for interception; without it, the page sees native WebAuthn behavior.

```csharp
await Credentials.InstallAsync();  
```

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

### ExampleTest inheriting WebView2Test

Source: https://playwright.dev/dotnet/docs/webview2

Example test that inherits from WebView2Test and verifies the Playwright homepage shows the 'Get Started' text. Uses the Page property from the base class.

```csharp
using Microsoft.Playwright;  

using Microsoft.Playwright.NUnit;  

using NUnit.Framework;  

  

namespace PlaywrightTests;  

  

[Parallelizable(ParallelScope.Self)]  

[TestFixture]  

public class ExampleTest : WebView2Test  

{  

    [Test]  

    public async Task HomepageHasPlaywrightInTitleAndGetStartedLinkLinkingtoTheIntroPage()  

    {  

        await Page.GotoAsync("https://playwright.dev");  

        var getStarted = Page.GetByText("Get Started");  

        await Expect(getStarted).ToBeVisibleAsync();  

    }  

}  
```

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

### NUnit API test setup with [SetUp] and [TearDown]

Source: https://playwright.dev/dotnet/docs/api-testing

Use [SetUp] and [TearDown] hooks to create and delete a test repository for API testing with NUnit. The [SetUp] method calls CreateAPIRequestContext() and CreateTestRepository(), while [TearDown] deletes the repository and disposes the request context.

```csharp
using System.Text.Json;  

using Microsoft.Playwright;  

using Microsoft.Playwright.NUnit;  

using NUnit.Framework;  

  

namespace PlaywrightTests;  

  

[Parallelizable(ParallelScope.Self)]  

[TestFixture]  

public class TestGitHubAPI : PlaywrightTest  

{  

    // ...  

    [SetUp]  

    public async Task SetUpAPITesting()  

    {  

        await CreateAPIRequestContext();  

        await CreateTestRepository();  

    }  

  

    private async Task CreateTestRepository()  

    {  

        var resp = await Request.PostAsync("/user/repos", new()  

        {  

            DataObject = new Dictionary<string, string>()  

            {  

                ["name"] = REPO,  

            },  

        });  

        await Expect(resp).ToBeOKAsync();  

    }  

  

    [TearDown]  

    public async Task TearDownAPITesting()  

    {  

        await DeleteTestRepository();  

        await Request.DisposeAsync();  

    }  

  

    private async Task DeleteTestRepository()  

    {  

        var resp = await Request.DeleteAsync("/repos/" + USER + "/" + REPO);  

        await Expect(resp).ToBeOKAsync();  

    }  

}  
```

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

### Install browser with dependencies (--with-deps)

Source: https://playwright.dev/dotnet/docs/browsers

Combines install and install-deps to install both the browser and its OS dependencies in a single command.

```powershell
pwsh bin/Debug/netX/playwright.ps1 install --with-deps chromium
```

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

### Run Selenium standalone container

Source: https://playwright.dev/dotnet/docs/selenium-grid

Starts a Selenium standalone Chromium container with SE_NODE_GRID_URL pointing to localhost, used as the first step in the standalone mode example.

```bash
docker run -d -p 4444:4444 --shm-size="2g" -e SE_NODE_GRID_URL="http://localhost:4444" selenium/standalone-chromium:latest  


```

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

### WebView2 test base class and example test

Source: https://playwright.dev/dotnet/docs/webview2

These two C# files form the WebView2 test setup and a sample test. The base class WebView2Test launches the WebView2 executable with remote debugging enabled, waits for the 'WebView2 initialized' output, and connects Playwright over CDP. The ExampleTest inherits from WebView2Test and uses the Page property to navigate and assert visibility.

```csharp
using System.Diagnostics;  

using Microsoft.Playwright;  

using Microsoft.Playwright.Xunit.v3;  

  

namespace PlaywrightTests;  

  

public class WebView2Test : PlaywrightTest  

{  

    public IBrowser Browser { get; internal set; } = null!;  

    public IBrowserContext Context { get; internal set; } = null!;  

    public IPage Page { get; internal set; } = null!;  

    private Process? _webView2Process = null;  

    private string _userDataDir = null!;  

    private string _executablePath = Path.Join(Directory.GetCurrentDirectory(), @"..\..\..\..\webview2-app\bin\Debug\net8.0-windows\webview2.exe");  

  

    public override async Task InitializeAsync()  

    {  

        await base.InitializeAsync();  

        var cdpPort = 10000 + WorkerIndex;  

        Assert.True(File.Exists(_executablePath), "Make sure that the executable exists");  

        _userDataDir = Path.Join(Path.GetTempPath(), $"playwright-webview2-tests/user-data-dir-{WorkerIndex}");  

        // WebView2 does some lazy cleanups on shutdown so we can't clean it up after each test  

        if (Directory.Exists(_userDataDir))  

        {  

            Directory.Delete(_userDataDir, true);  

        }  

        _webView2Process = Process.Start(new ProcessStartInfo(_executablePath)  

        {  

            EnvironmentVariables =  

        {  

            ["WEBVIEW2_ADDITIONAL_BROWSER_ARGUMENTS"] = $"--remote-debugging-port={cdpPort}",  

            ["WEBVIEW2_USER_DATA_FOLDER"] = _userDataDir,  

        },  

            RedirectStandardOutput = true,  

        });  

        while (!_webView2Process!.HasExited)  

        {  

            var output = await _webView2Process!.StandardOutput.ReadLineAsync();  

            if (_webView2Process!.HasExited)  

            {  

                throw new Exception("WebView2 process exited unexpectedly");  

            }  

            if (output != null && output.Contains("WebView2 initialized"))  

            {  

                break;  

            }  

        }  

        var cdpAddress = $"http://127.0.0.1:{cdpPort}";  

        Browser = await Playwright.Chromium.ConnectOverCDPAsync(cdpAddress);  

        Context = Browser.Contexts[0];  

        Page = Context.Pages[0];  

    }  

  

    public override async Task DisposeAsync()  

    {  

        _webView2Process!.Kill(true);  

        await Browser.CloseAsync();  

        await base.DisposeAsync();  

    }  

}  


```

```csharp
using Microsoft.Playwright;  

using Microsoft.Playwright.Xunit.v3;  

  

namespace PlaywrightTests;  

  

public class ExampleTest : WebView2Test  

{  

    [Fact]  

    public async Task HomepageHasPlaywrightInTitleAndGetStartedLinkLinkingtoTheIntroPage()  

    {  

        await Page.GotoAsync("https://playwright.dev");  

        var getStarted = Page.GetByText("Get Started");  

        await Expect(getStarted).ToBeVisibleAsync();  

    }  

}  


```

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

### Install playwright-cli globally and check help

Source: https://playwright.dev/dotnet/docs/getting-started-cli

Installs @playwright/cli globally and verifies the installation by showing help.

```bash
npm install -g @playwright/cli@latest  

playwright-cli --help  
```

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

### NUnit test hooks with SetUp/TearDown

Source: https://playwright.dev/dotnet/docs/writing-tests

Use [SetUp] and [TearDown] attributes to prepare and clean up the test environment in NUnit. The example shows a PageTest that navigates to the Playwright website before each test.

```csharp
using System.Threading.Tasks;  
using Microsoft.Playwright.NUnit;  
using NUnit.Framework;  

namespace PlaywrightTests;  

[Parallelizable(ParallelScope.Self)]  
[TestFixture]  
public class ExampleTest : PageTest  
{  
    [Test]  
    public async Task MainNavigation()  
    {  
        // Assertions use the expect API.  
        await Expect(Page).ToHaveURLAsync("https://playwright.dev/");  
    }  

    [SetUp]  
    public async Task SetUp()  
    {  
        await Page.GotoAsync("https://playwright.dev");  
    }  
}  

```

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

### xUnit trace on failure

Source: https://playwright.dev/dotnet/docs/trace-viewer

xUnit example that starts tracing in InitializeAsync and stops it in DisposeAsync, saving a trace zip only when the test fails. Uses Context.Tracing.StartAsync and StopAsync with a conditional path.

```csharp
using System.Reflection;  
using Microsoft.Playwright;  
using Microsoft.Playwright.Xunit;  
using Xunit.Sdk;  

namespace PlaywrightTests;  

[WithTestName]  
public class UnitTest1 : PageTest  
{  
    public override async Task InitializeAsync()  
    {  
        await base.InitializeAsync().ConfigureAwait(false);  
        await Context.Tracing.StartAsync(new()  
        {  
            Title = $"{WithTestNameAttribute.CurrentClassName}.{WithTestNameAttribute.CurrentTestName}",  
            Screenshots = true,  
            Snapshots = true,  
            Sources = true  
        });  
    }  

    public override async Task DisposeAsync()  
    {  
        await Context.Tracing.StopAsync(new()  
        {  
            Path = !TestOk ? Path.Combine(  
                Environment.CurrentDirectory,  
                "playwright-traces",  
               $"{WithTestNameAttribute.CurrentClassName}.{WithTestNameAttribute.CurrentTestName}.zip"  
            ) : null  
        });  
        await base.DisposeAsync().ConfigureAwait(false);  
    }  

    [Fact]  
    public async Task GetStartedLink()  
    {  
        // ...  
        await Page.GotoAsync("https://playwright.dev/dotnet/docs/intro");  
    }  
}  

public class WithTestNameAttribute : BeforeAfterTestAttribute  
{  
    public static string CurrentTestName = string.Empty;  
    public static string CurrentClassName = string.Empty;  

    public override void Before(MethodInfo methodInfo)  
    {  
        CurrentTestName = methodInfo.Name;  
        CurrentClassName = methodInfo.DeclaringType!.Name;  
    }  

    public override void After(MethodInfo methodInfo)  
    {  
    }  
}  

```

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

### Create an agentic video receipt with Screencast and locators

Source: https://playwright.dev/dotnet/docs/release-notes

Produces an agentic video receipt: records a walkthrough with action annotations and chapter titles for human review. The example shows starting a recording, performing verification steps with locators, adding context chapters, and stopping the recording.

```csharp
await page.Screencast.StartAsync(new() { Path = "receipt.webm" });  
await page.Screencast.ShowActionsAsync(new() { Position = "top-right" });  

await page.Screencast.ShowChapterAsync("Verifying checkout flow", new() {  
    Description = "Added coupon code support per ticket #1234",  
});  

// Agent performs the verification steps...  
await page.Locator("#coupon").FillAsync("SAVE20");  
await page.Locator("#apply-coupon").ClickAsync();  
await Expect(page.Locator(".discount")).ToContainTextAsync("20%");  

await page.Screencast.ShowChapterAsync("Done", new() {  
    Description = "Coupon applied, discount reflected in total",  
});  

await page.Screencast.StopAsync();  

```

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

### MSTest example test with Playwright PageTest

Source: https://playwright.dev/dotnet/docs/intro

MSTest test class extending PageTest with [TestClass] and [TestMethod] attributes. Contains the same two tests as the NUnit version: verifying the title and clicking the 'Get started' link to check the 'Installation' heading.

```csharp
using System.Text.RegularExpressions;  
using Microsoft.Playwright;  
using Microsoft.Playwright.MSTest;  
  
namespace PlaywrightTests;  
  
[TestClass]  
public class ExampleTest : PageTest  
{  
    [TestMethod]  
    public async Task HasTitle()  
    {  
        await Page.GotoAsync("https://playwright.dev");  
  
        // Expect a title "to contain" a substring.  
        await Expect(Page).ToHaveTitleAsync(new Regex("Playwright"));  
    }  
  
    [TestMethod]  
    public async Task GetStartedLink()  
    {  
        await Page.GotoAsync("https://playwright.dev");  
  
        // Click the get started link.  
        await Page.GetByRole(AriaRole.Link, new() { Name = "Get started" }).ClickAsync();  
  
        // Expects page to have a heading with the name of Installation.  
        await Expect(Page.GetByRole(AriaRole.Heading, new() { Name = "Installation" })).ToBeVisibleAsync();  
    }   
}  

```

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

### Show install command help

Source: https://playwright.dev/dotnet/docs/browsers

Displays help for the install command, listing all supported browsers and options.

```powershell
pwsh bin/Debug/netX/playwright.ps1 install --help
```

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

### install

Source: https://playwright.dev/dotnet/docs/clock

Initializes the clock and allows you to pause, fast forward, run for, and resume time.

```APIDOC
## install

### Description
Initializes the clock and allows you to pause, fast forward, run for, and resume time.

### Method
install

### Parameters
- **options** (object) - Optional - Configuration options for the clock installation.

### Response
Returns a Clock object with methods to control time.

```

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

### NUnit example test with Playwright PageTest

Source: https://playwright.dev/dotnet/docs/intro

NUnit test class extending PageTest with two tests: HasTitle checks the page title contains 'Playwright', and GetStartedLink clicks the 'Get started' link and verifies the 'Installation' heading is visible. Uses Microsoft.Playwright.NUnit and NUnit.Framework.

```csharp
using System.Text.RegularExpressions;  
using System.Threading.Tasks;  
using Microsoft.Playwright;  
using Microsoft.Playwright.NUnit;  
using NUnit.Framework;  
  
namespace PlaywrightTests;  
  
[Parallelizable(ParallelScope.Self)]  
[TestFixture]  
public class ExampleTest : PageTest  
{  
    [Test]  
    public async Task HasTitle()  
    {  
        await Page.GotoAsync("https://playwright.dev");  
  
        // Expect a title "to contain" a substring.  
        await Expect(Page).ToHaveTitleAsync(new Regex("Playwright"));  
    }  
  
    [Test]  
    public async Task GetStartedLink()  
    {  
        await Page.GotoAsync("https://playwright.dev");  
  
        // Click the get started link.  
        await Page.GetByRole(AriaRole.Link, new() { Name = "Get started" }).ClickAsync();  
  
        // Expects page to have a heading with the name of Installation.  
        await Expect(Page.GetByRole(AriaRole.Heading, new() { Name = "Installation" })).ToBeVisibleAsync();  
    }   
}  

```

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

### CLI output snapshot example

Source: https://playwright.dev/dotnet/docs/getting-started-cli

Example output from the CLI after running commands, showing page URL, title, and a snapshot link.

```text
### Page  

- Page URL: https://demo.playwright.dev/todomvc/#/  

- Page Title: React • TodoMVC  

### Snapshot  

[Snapshot](.playwright-cli/page-2026-02-14T19-22-42-679Z.yml)  

```

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

### Start Selenium hub and node containers

Source: https://playwright.dev/dotnet/docs/selenium-grid

Commands to start the Selenium hub and a node container, with SE_NODE_GRID_URL pointing to the hub. Hub and node have different IPs.

```bash
docker run -d -p 4442-4444:4442-4444 --name selenium-hub selenium/hub:4.25.0  

docker run -d -p 5555:5555 \  

    --shm-size="2g" \  

    -e SE_EVENT_BUS_HOST=<selenium-hub-ip> \  

    -e SE_EVENT_BUS_PUBLISH_PORT=4442 \  

    -e SE_EVENT_BUS_SUBSCRIBE_PORT=4443 \  

    -e SE_NODE_GRID_URL="http://<selenium-hub-ip>:4444"  

    selenium/node-chromium:4.25.0  


```

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

### NUnit trace recording with PageTest

Source: https://playwright.dev/dotnet/docs/trace-viewer

NUnit example using PageTest with SetUp and TearDown to start and stop tracing. The trace is saved to a zip file in the playwright-traces folder under the test work directory.

```csharp
namespace PlaywrightTests;  

  

[Parallelizable(ParallelScope.Self)]  

[TestFixture]  

public class Tests : PageTest  

{  
    [SetUp]  
    public async Task Setup()  
    {  
        await Context.Tracing.StartAsync(new()  
        {  
            Title = TestContext.CurrentContext.Test.ClassName + "." + TestContext.CurrentContext.Test.Name,  
            Screenshots = true,  
            Snapshots = true,  
            Sources = true  
        });  
    }  

    [TearDown]  
    public async Task TearDown()  
    {  
        // This will produce e.g.:  
        // bin/Debug/net8.0/playwright-traces/PlaywrightTests.Tests.Test1.zip  
        await Context.Tracing.StopAsync(new()  
        {  
            Path = Path.Combine(  
                TestContext.CurrentContext.WorkDirectory,  
                "playwright-traces",  
                $"{TestContext.CurrentContext.Test.ClassName}.{TestContext.CurrentContext.Test.Name}.zip"  
            )  
        });  
    }  

    [Test]  
    public async Task TestYourOnlineShop()  
    {  
        // ..  
    }  
}  
```

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

### xUnit example test with Playwright PageTest

Source: https://playwright.dev/dotnet/docs/intro

xUnit test class extending PageTest with [Fact] attributes. Uses Microsoft.Playwright.Xunit and contains the same two tests: title check and 'Get started' link navigation.

```csharp
using System.Text.RegularExpressions;  
using Microsoft.Playwright;  
using Microsoft.Playwright.Xunit;  
  
namespace PlaywrightTests;  
  
public class UnitTest1: PageTest  
{  
    [Fact]  
    public async Task HasTitle()  
    {  
        await Page.GotoAsync("https://playwright.dev");  
  
        // Expect a title "to contain" a substring.  
        await Expect(Page).ToHaveTitleAsync(new Regex("Playwright"));  
    }  
  
    [Fact]  
    public async Task GetStartedLink()  
    {  
        await Page.GotoAsync("https://playwright.dev");  
  
        // Click the get started link.  
        await Page.GetByRole(AriaRole.Link, new() { Name = "Get started" }).ClickAsync();  
  
        // Expects page to have a heading with the name of Installation.  
        await Expect(Page.GetByRole(AriaRole.Heading, new() { Name = "Installation" })).ToBeVisibleAsync();  
    }   
}  

```

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

### xUnit v3 example test with Playwright PageTest

Source: https://playwright.dev/dotnet/docs/intro

xUnit v3 test class extending PageTest with [Fact] attributes. Uses Microsoft.Playwright.Xunit.v3 and contains the same two tests: title check and 'Get started' link navigation.

```csharp
using System.Text.RegularExpressions;  
using Microsoft.Playwright;  
using Microsoft.Playwright.Xunit.v3;  
  
namespace PlaywrightTests;  
  
public class UnitTest1: PageTest  
{  
    [Fact]  
    public async Task HasTitle()  
    {  
        await Page.GotoAsync("https://playwright.dev");  
  
        // Expect a title "to contain" a substring.  
        await Expect(Page).ToHaveTitleAsync(new Regex("Playwright"));  
    }  
  
    [Fact]  
    public async Task GetStartedLink()  
    {  
        await Page.GotoAsync("https://playwright.dev");  
  
        // Click the get started link.  
        await Page.GetByRole(AriaRole.Link, new() { Name = "Get started" }).ClickAsync();  
  
        // Expects page to have a heading with the name of Installation.  
        await Expect(Page.GetByRole(AriaRole.Heading, new() { Name = "Installation" })).ToBeVisibleAsync();  
    }   
}  

```

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

### Quick Guide: Fill and click using built-in locators

Source: https://playwright.dev/dotnet/docs/locators

Shows a typical login flow using GetByLabel for inputs and GetByRole for the sign-in button, then asserts visibility with GetByText.

```csharp
await Page.GetByLabel("User Name").FillAsync("John");  

await Page.GetByLabel("Password").FillAsync("secret-password");  

await Page.GetByRole(AriaRole.Button, new() { Name = "Sign in" }).ClickAsync();  

await Expect(Page.GetByText("Welcome, John!")).ToBeVisibleAsync();  
```

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

### Generated test with assertion tools

Source: https://playwright.dev/dotnet/docs/release-notes

Example of a test generated by the Test Generator with new assertion tools. It navigates to the Playwright website, clicks the 'Get started' link, and uses the new assertion methods ToContainTextAsync, ToBeVisibleAsync, and ToHaveValueAsync to verify breadcrumbs, search visibility, and search input value.

```csharp
await Page.GotoAsync("https://playwright.dev/");  

await Page.GetByRole(AriaRole.Link, new() { Name = "Get started" }).ClickAsync();  

await Expect(Page.GetByLabel("Breadcrumbs").GetByRole(AriaRole.List)).ToContainTextAsync("Installation");  

await Expect(Page.GetByLabel("Search")).ToBeVisibleAsync();  

await Page.GetByLabel("Search").ClickAsync();  

await Page.GetByPlaceholder("Search docs").FillAsync("locator");  

await Expect(Page.GetByPlaceholder("Search docs")).ToHaveValueAsync("locator");  

```

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

### InstallAsync usage

Source: https://playwright.dev/dotnet/docs/api/class-clock

Install fake implementations for time-related functions. Optionally accepts a ClockInstallOptions with a Time property to initialize the clock.

```csharp
await Clock.InstallAsync(options);  
```

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

### Install Playwright browsers with PowerShell

Source: https://playwright.dev/dotnet/docs/intro

Installs the required browsers using the playwright.ps1 script. The example uses net8.0; adjust the path if using a different .NET version. Requires PowerShell (pwsh) to be installed.

```powershell
pwsh bin/Debug/net8.0/playwright.ps1 install  

```

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

### Handle a download with WaitForDownloadAsync and SaveAsAsync

Source: https://playwright.dev/dotnet/docs/api/class-download

Shows the recommended pattern for handling a download: start waiting for the Download event before triggering the download, then save the file once the download completes.

```csharp
// Start the task of waiting for the download before clicking  

var waitForDownloadTask = page.WaitForDownloadAsync();  

await page.GetByText("Download file").ClickAsync();  

var download = await waitForDownloadTask;  

  

// Wait for the download process to complete and save the downloaded file somewhere  

await download.SaveAsAsync("/path/to/save/at/" + download.SuggestedFilename);  

```

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

### Get frame element with Frame.FrameElementAsync()

Source: https://playwright.dev/dotnet/docs/api/class-frame

This example demonstrates Frame.FrameElementAsync() to get the frame or iframe element handle, then uses ElementHandle.ContentFrameAsync() to get the content frame and compares them. It throws an error if the frame is detached before the call returns.

```csharp
var frameElement = await frame.FrameElementAsync();  

var contentFrame = await frameElement.ContentFrameAsync();  

Console.WriteLine(frame == contentFrame); // -> True  

```

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

### LaunchAsync

Source: https://playwright.dev/dotnet/docs/api/class-browsertype

Launches a new browser instance with optional configuration options. Returns a Browser object.

```APIDOC
## LaunchAsync

### Description
Launches a new browser instance with the specified options. Returns a Browser object.

### Method
LaunchAsync

### Endpoint
browserType.LaunchAsync

### Parameters
#### Options (BrowserTypeLaunchOptions?)
- **Args** (IEnumerable<string>?) - Optional - Additional arguments to pass to the browser instance. Use with caution as some may break Playwright functionality.
- **ArtifactsDir** (string?) - Optional - Directory to save artifacts (traces, videos, downloads, HAR files, etc.). If not specified, a temporary directory is used and cleaned up when the browser closes.
- **Channel** (string?) - Optional - Browser distribution channel. Use "chromium" for new headless mode, or "chrome", "chrome-beta", "msedge", etc. for branded browsers.
- **ChromiumSandbox** (bool?) - Optional - Enable Chromium sandboxing. Defaults to false.
- **DownloadsPath** (string?) - Optional - Directory for accepted downloads. If not specified, a temporary directory is created and deleted when the browser is closed.
- **Env** (IDictionary<string, string>?) - Optional - Environment variables visible to the browser. Defaults to process.env.
- **ExecutablePath** (string?) - Optional - Path to a browser executable to run instead of the bundled one. Use with extreme caution.
- **FirefoxUserPrefs** (IDictionary<string, object>?) - Optional - Firefox user preferences. Can also provide a path to a custom policies.json via PLAYWRIGHT_FIREFOX_POLICIES_JSON.
- **HandleSIGHUP** (bool?) - Optional - Close the browser process on SIGHUP. Defaults to true.
- **HandleSIGINT** (bool?) - Optional - Close the browser process on Ctrl-C. Defaults to true.
- **HandleSIGTERM** (bool?) - Optional - Close the browser process on SIGTERM. Defaults to true.
- **Headless** (bool?) - Optional - Whether to run browser in headless mode. Defaults to true.
- **IgnoreAllDefaultArgs** (bool?) - Optional - If true, Playwright does not pass its own configuration args and only uses the ones from Args. Dangerous option; use with care. Defaults to false.
- **IgnoreDefaultArgs** (IEnumerable<string>?) - Optional - If true, Playwright does not pass its own configuration args and only uses the ones from Args. Dangerous option; use with care.
- **Proxy** (Proxy?) - Optional - Network proxy settings. Contains Server, Bypass, Username, Password.
- **SlowMo** (float?) - Optional - Slows down Playwright operations by the specified amount of milliseconds.
- **Timeout** (float?) - Optional - Maximum time in milliseconds to wait for the browser instance to start. Defaults to 30000 (30 seconds). Pass 0 to disable timeout.
- **TracesDir** (string?) - Optional - If specified, traces are saved into this directory.

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

### Usage Example
```csharp
var browser = await playwright.Chromium.LaunchAsync(new() {
    IgnoreDefaultArgs = new[] { "--mute-audio" }
});
```
```

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

### Playwright.Selectors

Source: https://playwright.dev/dotnet/docs/api/class-playwright

Gets the Selectors object, which can be used to install custom selector engines.

```APIDOC
## [GET] /playwright/selectors

### Description
Gets the Selectors object, which can be used to install custom selector engines.

### Method
GET

### Endpoint
/playwright/selectors

### Parameters
#### Path Parameters
- **none** - No path parameters.

#### Query Parameters
- **none** - No query parameters.

### Request Example
{}

### Response
#### Success Response (200)
- **selectors** (Selectors) - The Selectors object.

#### Response Example
{
  "selectors": {}
}
```

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

### BrowserType.LaunchAsync

Source: https://playwright.dev/dotnet/docs/api/class-browsertype

Launches a new browser instance with the specified options and returns a BrowserContext.

```APIDOC
## BrowserType.LaunchAsync

### Description
Launches a new browser instance with the specified options and returns a BrowserContext. The method waits for the browser to start, with configurable timeout, timezone, traces directory, user agent, and viewport size.

### Method
POST

### Endpoint
BrowserType.LaunchAsync

### Parameters
#### Request Body
- **Timeout** (float) - Optional - Maximum time in milliseconds to wait for the browser instance to start. Defaults to 30000 (30 seconds). Pass 0 to disable timeout.
- **TimezoneId** (string) - Optional - Changes the timezone of the context. See ICU's metaZones.txt for a list of supported timezone IDs. Defaults to the system timezone.
- **TracesDir** (string) - Optional - If specified, traces are saved into this directory.
- **UserAgent** (string) - Optional - Specific user agent to use in this context.
- **ViewportSize** (object) - Optional - Emulates consistent viewport for each page. Defaults to an 1280x720 viewport. Use ViewportSize.NoViewport to disable the consistent viewport emulation.
  - **Width** (int) - Required - Page width in pixels.
  - **Height** (int) - Required - Page height in pixels.

### Request Example
```json
{
  "Timeout": 30000,
  "TimezoneId": "America/New_York",
  "TracesDir": "traces",
  "UserAgent": "Mozilla/5.0",
  "ViewportSize": {
    "Width": 1280,
    "Height": 720
  }
}
```

### Response
#### Success Response (200)
- **BrowserContext** - The created browser context.

#### Response Example
```json
{
  "browserContextId": "abc123"
}
```
```

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

### Get properties of a JSHandle

Source: https://playwright.dev/dotnet/docs/api/class-jshandle

Gets a map of the object's own property names to JSHandle instances for their values. The example retrieves the window and document properties and then disposes the handle.

```csharp
var handle = await page.EvaluateHandleAsync("() => ({ window, document }");

var properties = await handle.GetPropertiesAsync();

var windowHandle = properties["window"];

var documentHandle = properties["document"];

await handle.DisposeAsync();
```

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

### Get redirectedFrom URL after redirect

Source: https://playwright.dev/dotnet/docs/api/class-request

Shows how to get the original request URL after a redirect. The example navigates to http://www.microsoft.com and prints the URL of the request that was redirected from, which is http://www.microsoft.com.

```csharp
var response = await page.GotoAsync("http://www.microsoft.com");  

Console.WriteLine(response.Request.RedirectedFrom?.Url); // http://www.microsoft.com  

```

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

### Context usage

Source: https://playwright.dev/dotnet/docs/api/class-page

Gets the browser context that the page belongs to. The example shows the property access.

```csharp
Page.Context  
```

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

### StartAsync

Source: https://playwright.dev/dotnet/docs/api/class-tracing

Starts tracing. This method begins recording trace data for the current context. It accepts options to control what is captured, such as screenshots, snapshots, and source files.

```APIDOC
## [POST] /tracing/start

### Description
Starts tracing. This method begins recording trace data for the current context. It accepts options to control what is captured, such as screenshots, snapshots, and source files.

### Method
POST

### Endpoint
/tracing/start

### Parameters
#### Request Body
- **options** (TracingStartOptions?) - Optional - Options for starting tracing.
  - **AriaSnapshots** (bool?) - Optional - Whether to capture aria snapshot of the page on every action.
  - **Live** (bool?) - Optional - When enabled, the trace is written to an unarchived file that is updated in real time as actions occur.
  - **Name** (string?) - Optional - If specified, intermediate trace files are going to be saved into the files with the given name prefix.
  - **Screenshots** (bool?) - Optional - Whether to capture screenshots during tracing.
  - **ScreenSnapshots** (bool?) - Optional - Whether to capture a screenshot of the page on every action.
  - **Snapshots** (bool?) - Optional - Whether to capture DOM snapshot and record network activity on every action.
  - **Sources** (bool?) - Optional - Whether to include source files for trace actions.
  - **Title** (string?) - Optional - Trace name to be shown in the Trace Viewer.

### Request Example
{
  "Screenshots": true,
  "Snapshots": true
}

### Response
#### Success Response (200)
- **void** - No return value.

#### Response Example
{}
```

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

### Get iframe element locator with FrameLocator.Owner

Source: https://playwright.dev/dotnet/docs/api/class-framelocator

Use to obtain a Locator for the iframe element from an existing FrameLocator. The example shows getting a frame locator, then later retrieving its owner locator and asserting visibility.

```csharp
var frameLocator = Page.Locator("iframe[name=\"embedded\"]").ContentFrame;  

// ...  

var locator = frameLocator.Owner;  

await Expect(locator).ToBeVisibleAsync();  

```

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

### Access Playwright.Selectors property

Source: https://playwright.dev/dotnet/docs/api/class-playwright

Usage example for the Selectors property, which can be used to install custom selector engines.

```csharp
Playwright.Selectors  
```

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

### Run example tests with dotnet test

Source: https://playwright.dev/dotnet/docs/intro

Runs the example tests on Chromium by default. Tests run in headless mode, so no browser window opens; results and logs appear in the terminal. Configure the browser via the BROWSER environment variable or launch configuration options.

```bash
dotnet test  
```

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

### Start Selenium node with SE_NODE_GRID_URL

Source: https://playwright.dev/dotnet/docs/selenium-grid

Command to start a Selenium node, setting SE_NODE_GRID_URL to point to the hub so Playwright can connect to browsers. Required for distributed grids.

```bash
# Start selenium node  

SE_NODE_GRID_URL="http://<selenium-hub-ip>:4444" java -jar selenium-server-<version>.jar node  


```

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

### Get dialog message with Dialog.Message

Source: https://playwright.dev/dotnet/docs/api/class-dialog

Usage example for Dialog.Message property. Returns the message displayed in the dialog.

```csharp
Dialog.Message  


```

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

### Frame: Get frame by name or URL

Source: https://playwright.dev/dotnet/docs/api/class-page

Returns a frame matching the specified criteria. Either 'name' or 'url' must be specified. The first example gets a frame by its name attribute, the second by a URL pattern.

```csharp
var frame = page.Frame("frame-name");  
```

```csharp
var frame = page.FrameByUrl(".*url.*");  
```

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

### Configure TLS client certificate with Browser.NewContextAsync

Source: https://playwright.dev/dotnet/docs/release-notes

Sets up a client certificate for https://example.com when creating a browser context. The certificate is provided as a parameter of Browser.NewContextAsync() and enables TLS Client Authentication.

```csharp
var context = await Browser.NewContextAsync(new() {  

  ClientCertificates = [  

    new() {  

      Origin = "https://example.com",  

      CertPath = "client-certificates/cert.pem",  

      KeyPath = "client-certificates/key.pem",  

    }  

  ]  

});  

```

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

### Create and set up a Playwright .NET console project

Source: https://playwright.dev/dotnet/docs/library

Commands to create a console project, add the Microsoft.Playwright package, build, and install browsers. Replace netX with the actual output folder name (e.g., net8.0). If pwsh fails with TypeNotFound, update PowerShell with dotnet tool update --global PowerShell.

```bash
# Create project  

dotnet new console -n PlaywrightDemo  

cd PlaywrightDemo  

  

# Add project dependency  

dotnet add package Microsoft.Playwright  

# Build the project  

dotnet build  

# Install required browsers - replace netX with actual output folder name, e.g. net8.0.  

pwsh bin/Debug/netX/playwright.ps1 install  

  

# If the pwsh command does not work (throws TypeNotFound), make sure to use an up-to-date version of PowerShell.  

dotnet tool update --global PowerShell  

```

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

### Get dialog page with Dialog.Page

Source: https://playwright.dev/dotnet/docs/api/class-dialog

Usage example for Dialog.Page property. Returns the page that initiated the dialog, if available.

```csharp
Dialog.Page  


```

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

### ContentAsync usage

Source: https://playwright.dev/dotnet/docs/api/class-page

Gets the full HTML contents of the page, including the doctype. The example shows the basic call with no arguments.

```csharp
await Page.ContentAsync();  
```

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

### InstallAsync

Source: https://playwright.dev/dotnet/docs/api/class-clock

Installs fake implementations for time-related functions such as Date, setTimeout, setInterval, and performance. Allows manual control of time flow in tests.

```APIDOC
## InstallAsync

### Description
Install fake implementations for the following time-related functions: Date, setTimeout, clearTimeout, setInterval, clearInterval, requestAnimationFrame, cancelAnimationFrame, requestIdleCallback, cancelIdleCallback, performance. Fake timers are used to manually control the flow of time in tests.

### Method
InstallAsync

### Arguments
- **options** (ClockInstallOptions?) - Optional - Options for installation.
  - **Time|TimeDate** (string? | Date?) - Optional - Time to initialize with, current system time by default.

### Returns
void

### Usage Example
```csharp
await Clock.InstallAsync(options);
```
```

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

### Get dialog type with Dialog.Type

Source: https://playwright.dev/dotnet/docs/api/class-dialog

Usage example for Dialog.Type property. Returns the dialog type, which can be 'alert', 'beforeunload', 'confirm', or 'prompt'.

```csharp
Dialog.Type  


```

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

### CSS: HTML example with multiple similar buttons

Source: https://playwright.dev/dotnet/docs/other-locators

HTML snippet showing three 'Buy' buttons in different containers, used to illustrate :nth-match selection.

```html
<section>  
  <button>Buy</button>  
</section>  
<article>  
  <div>  
    <button>Buy</button>  
  </div>  
</article>  
<div>  
  <div>  
    <button>Buy</button>  
  </div>  
</div>  

```

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

### Install clock and fast-forward with Page.Clock.InstallAsync

Source: https://playwright.dev/dotnet/docs/clock

Use this pair when timers depend on Date.now and need consistent time progression. The HTML page renders the time every second; the C# test installs the clock at an initial time, navigates, pauses at a target time, asserts, then fast-forwards and asserts again.

```html
<div id="current-time" data-testid="current-time"></div>  

<script>  

  const renderTime = () => {  

    document.getElementById('current-time').textContent =  

        new Date().toLocaleString();  

  };  

  setInterval(renderTime, 1000);  

</script>  


```

```csharp
// Initialize clock with some time before the test time and let the page load naturally.  

// `Date.now` will progress as the timers fire.  

await Page.Clock.InstallAsync(new()  

{  

  TimeDate = new DateTime(2024, 2, 2, 8, 0, 0)  

});  

await Page.GotoAsync("http://localhost:3333");  

  

// Pretend that the user closed the laptop lid and opened it again at 10am.  

// Pause the time once reached that point.  

await Page.Clock.PauseAtAsync(new DateTime(2024, 2, 2, 10, 0, 0));  

  

// Assert the page state.  

await Expect(Page.GetByTestId("current-time")).ToHaveTextAsync("2/2/2024, 10:00:00 AM");  

  

// Close the laptop lid again and open it at 10:30am.  

await Page.Clock.FastForwardAsync("30:00");  

await Expect(Page.GetByTestId("current-time")).ToHaveTextAsync("2/2/2024, 10:30:00 AM");  


```

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

### Get request timing information

Source: https://playwright.dev/dotnet/docs/api/class-request

Shows how to obtain timing information for a request. The example waits for the request to finish and then prints the responseEnd timing value.

```csharp
var request = await page.RunAndWaitForRequestFinishedAsync(async () =>  

{  

    await page.GotoAsync("https://www.microsoft.com");  

});  

Console.WriteLine(request.Timing.ResponseEnd);  

```

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

### InstallAsync

Source: https://playwright.dev/dotnet/docs/api/class-credentials

Installs the virtual authenticator on the browser context, enabling it to answer WebAuthn ceremonies.

```APIDOC
## InstallAsync

### Description
Installs the virtual authenticator on the browser context, enabling it to answer WebAuthn ceremonies.

### Method
InstallAsync

### Endpoint
context.Credentials.InstallAsync()

### Parameters
None

### Request Example
```json
{}
```

### Response
#### Success Response
No response body is returned.

### Response Example
```json
{}
```
```

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

### BrowserContext.Page event handler

Source: https://playwright.dev/dotnet/docs/api/class-browsercontext

Subscribe to the Page event to be notified when a new page is created in the context. The example shows how to wait for a popup page and get its URL.

```csharp
var popup = await context.RunAndWaitForPageAsync(async =>  

{  

    await page.GetByText("open new page").ClickAsync();  

});  

Console.WriteLine(await popup.EvaluateAsync<string>("location.href"));
```

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

### Query all matching elements with playwright.$$(selector)

Source: https://playwright.dev/dotnet/docs/debug

Use playwright.$$() to get all elements matching a selector. The example shows querying list items with text 'John'.

```javascript
playwright.$$('li >> text=John')  

  

[<li>, <li>, <li>, <li>]
```

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

### Create a locator and click it

Source: https://playwright.dev/dotnet/docs/writing-tests

Creates a locator for a link with the role 'Link' and name 'Get started', then clicks it. Playwright waits for the element to be actionable before performing the action.

```csharp
// Create a locator.
var getStarted = Page.GetByRole(AriaRole.Link, new() { Name = "Get started" });

// Click it.
await getStarted.ClickAsync();
```
Tokens:
Raw