How to Migrate from Cypress to Playwright

End-to-end testing is a crucial part of any modern web application development process, ensuring that your application works seamlessly from the user’s perspective. Cypress and Playwright are two popular end-to-end testing tools that enable developers to write and run tests simulating real user interactions. While Cypress has been a popular choice for many developers, Playwright has gained traction due to its improved browser support, enhanced reliability, and powerful API.

If you’re considering switching from Cypress to Playwright, you’re in the right place. In this comprehensive guide, we’ll walk you through the entire process of migrating your test suite from Cypress to Playwright, ensuring a smooth transition with minimal disruption to your development workflow. We’ll cover everything from understanding the key differences between the two tools, setting up Playwright, rewriting your test cases, and integrating Playwright into your development process.

So, whether you’re a seasoned testing veteran or new to end-to-end testing, this guide will provide you with the information and best practices needed to migrate from Cypress to Playwright successfully. Let’s get started.

Overview of Cypress and Playwright

The key features and differences between Cypress and Playwright are


 Explicitly designed for end-to-end testing of web applications.

  • Built on top of JavaScript and runs directly in the browser.
  • Real-time reloading allows for quick and efficient test development.
  • Offers a rich and interactive UI for running and debugging tests.
  • Limited to running tests in Chromium-based browsers (e.g., Chrome, Electron).


  • A Node.js library for end-to-end testing of web applications.
  • Supports testing in multiple browsers, including Chromium, Firefox, and WebKit (Safari).
  • Provides a robust API for handling network requests and working with iframes and web components.
  • Enables running tests in headless mode, useful for CI/CD pipelines.
  • Offers auto-waiting mechanisms to reduce flakiness and improve test reliability.

Pros and Cons:

 Cypress Pros:

 Easy to set up and use, with a shallow learning curve.

  • Excellent real-time feedback during test development.
  • Well-documented and supported by a large community.

Cypress Cons:

  • Limited to Chromium-based browsers.
  • Can struggle with handling iframes, new browser windows, and web components.

Playwright Pros:

  • Cross-browser testing support (Chromium, Firefox, WebKit).
  • Powerful API for complex testing scenarios.
  • Better handling of iframes, new browser windows, and web components.
  • Improved reliability with auto-waiting mechanisms.

Playwright Cons:

  • Slightly steeper learning curve compared to Cypress.
  • Lacks a built-in interactive UI for running and debugging tests.

Preparing for the Migration

Evaluating your Current Test Suite

Before diving into the migration, it’s essential to evaluate your existing Cypress test suite. This includes:

  • Reviewing the total number of test cases and their complexity.
  • Assessing the usage of Cypress-specific features or plugins.
  • Identifying tests that are browser-specific or rely on browser APIs.
  • Documenting any custom or third-party integrations in your current setup.

Identifying areas that need Modification or Improvement

When migrating from Cypress to Playwright, you may encounter syntax, API, and supported features differences. Recognizing these differences beforehand will help streamline the migration process. Areas to focus on include:

  • Test syntax: Familiarize yourself with Playwright’s test syntax and identify any areas where your current Cypress tests may need modification.
  • Assertion libraries: Playwright doesn’t include a built-in assertion library, so you must choose one (e.g., Jest, Chai) and adapt your tests accordingly.
  • Custom commands: If you have custom Cypress commands, you’ll need to rewrite them as Playwright functions or find equivalent Playwright APIs.

Creating a Migration Plan

A well-structured migration plan will minimize disruption and help ensure a smooth transition. Consider the following when creating your plan:

  • Prioritize the migration of critical or high-impact tests.
  • Break the migration process into smaller, manageable phases.
  • Allocate enough time and resources for testing, debugging, and addressing any issues that arise during the migration.
  • Communicate the plan and timeline to your team, and provide any necessary training on Playwright.
  • Set up a parallel testing environment to run both Cypress and Playwright tests during the migration process, ensuring continuous test coverage.

Setting up Playwright

Installing Playwright and necessary Dependencies

To get started with Playwright, you’ll need to install it and its dependencies in your project. Follow these steps:

  1. Open a terminal in your project’s root directory.
  2. Install Playwright using npm or yarn:


npm install playwright





yarn add playwright

  1. Install the test runner of your choice. Playwright is compatible with various test runners, such as Jest or Mocha. For example, to install Jest:


npm install jest





yarn add jest

  1. Install the assertion library of your choice, like Chai or Expect (if not already included with your test runner).

Configuring your project for Playwright

After installing the necessary dependencies, you’ll need to configure your project for Playwright. This involves setting up your test runner and writing a configuration file.

  1. Create a configuration file for your test runner (e.g., jest.config.js for Jest) in your project’s root directory.
  2. Configure the test runner to use Playwright. For Jest, you can use the jest-playwright-preset package:


npm install jest-playwright-preset





yarn add jest-playwright-preset

  1. Then, update your jest.config.js to use the preset:



module.exports = {

preset: ‘jest-playwright-preset’,


  1. Configure your test runner to use the assertion library you’ve chosen.

Understanding the Playwright API

Before migrating your test cases, it’s essential to familiarize yourself with the Playwright API. Key concepts include:

  • Browser contexts: Isolated environments that represent a single user session with separate cookies, local storage, and other data.
  • Pages: Represent an open browser tab or window. You can interact with pages, such as navigating to URLs, filling out forms, and clicking buttons.
  • Selectors: Used to interact with elements on the page. Playwright supports various selector engines, including CSS, XPath, and text-based selectors.
  • Network interception: Playwright can intercept and modify network requests and responses, enabling you to mock API calls or test different server responses.

Migrating Test Cases

Rewriting Cypress test cases in Playwright syntax

To migrate your test cases, you’ll need to rewrite them using Playwright syntax. This involves replacing Cypress commands with equivalent Playwright functions, such as:


  • visit() -> page.goto()
  • get() -> page.$()
  • type() -> page.type()

Adapting to Playwright’s Test Runner and Assertion Library

When migrating your test cases, you must adapt them to the test runner and assertion library you’ve chosen. For example, if you’ve chosen Jest and expect:

  • Replace Cypress assertions (e.g., cy.should()) with expect assertions (e.g., expect().toBe()).
  • Update test suite and test case declarations to use Jest syntax (describe() and test() or it()).

Handling Common Migration Challenges and Best Practices

During the migration process, you may encounter challenges due to differences in syntax, API, and supported features. Here are some best practices to help you:

  • Familiarize yourself with Playwright’s auto-waiting mechanisms, which can help reduce flakiness and improve test reliability.
  • Replace custom Cypress commands with equivalent Playwright functions or APIs.
  • If your Cypress tests rely on browser-specific features or APIs, ensure they are compatible with the browsers you plan to test in Playwright.

Cross-Browser Testing in Playwright

One of the main advantages of Playwright is its ability to perform cross-browser testing. To leverage this capability:

  1. Update your test runner configuration to specify the browsers you want to test. For example, in jest.config.js:


module.exports = {

preset: ‘jest-playwright-preset’,

testRunner: ‘groups’,

browsers: [‘chromium’, ‘firefox’, ‘webkit’],


  1. Ensure your test cases are compatible with all target browsers. This may involve:
  • Verifying that your selectors work consistently across browsers.
  • Handling browser-specific behavior or quirks.
  • Adapting your tests to accommodate varying performance characteristics of different browsers.
  • Taking help from cloud-based platforms, e.g., LambdaTest.

LambdaTest is a cloud-based digital experience testing platform that offers seamless integration with Playwright, an open-source Node.js library for browser automation. It provides a wide range of real browsers, operating systems, and devices for testing, enabling you to ensure the compatibility of your web applications across different environments.

LambdaTest also supports parallel testing, allowing you to execute Playwright tests simultaneously across multiple browsers and devices, reducing test execution time. Additionally, LambdaTest offers debugging and troubleshooting tools, including screenshot capture, video recording, and integrated developer tools, to identify and resolve issues quickly. It integrates with popular test automation frameworks and CI/CD tools, enabling seamless incorporation of Playwright tests into your development pipeline. LambdaTest generates detailed test logs and reports, providing insights into test execution and facilitating collaboration within the team.

  1. Regularly run your test suite in all target browsers to ensure consistent behavior and identify any browser-specific issues.

By following these steps and best practices, you can successfully migrate your test suite from Cypress to Playwright, benefiting from improved browser support, enhanced reliability, and a robust API for end-to-end testing. As you work through the migration process, don’t hesitate to consult the Playwright documentation and community resources for guidance and support.

Integrating Playwright into Your Development Workflow

CI/CD Pipeline Integration

Integrating Playwright into your CI/CD pipeline is essential for automating testing and ensuring quality throughout your development process. Follow these steps to integrate Playwright with popular CI platforms like GitHub Actions, GitLab CI, or Jenkins:

  1. Update your CI configuration file to include the necessary dependencies and environment setup for Playwright.
  2. Configure your CI environment to run your test suite in headless mode and across all target browsers.
  3. Add appropriate triggers to run tests on every commit, pull request, or release, depending on your workflow.


Reporting and Monitoring Test Results

Tracking and monitoring test results is crucial for identifying and addressing issues quickly. Consider implementing the following:

  1. Choose a test reporting tool that integrates with your test runner and CI platform (e.g., Allure, TestRail, or custom reporting solutions).
  2. Configure your test runner to generate test reports in the format your reporting tool requires.
  3. Set up notifications and alerts to inform your team of test failures or performance regressions.

Updating Documentation and Training Team Members

As you integrate Playwright into your development workflow, ensure your team is prepared for the transition:

  1. Update your internal documentation to reflect the migration from Cypress to Playwright, including details on syntax, API, and best practices.
  2. Organize training sessions or workshops to help your team get up to speed with Playwright and the new testing process.
  3. Encourage team members to participate in code reviews and pair programming to share knowledge and best practices.

Tips for a Smooth Transition

Troubleshooting Common Migration Issues

During the migration process, you may encounter issues related to differences in syntax, API, or supported features. To troubleshoot these issues:

  1. Consult the Playwright documentation for guidance on API usage and best practices.
  2. Search the Playwright GitHub repository for known issues or solutions to similar problems.
  3. Reach out to the Playwright community via forums, Slack, or Stack Overflow for advice and support.

Ensuring Test Reliability and Performance

To maintain test reliability and performance during and after the migration, consider the following:

  • Leverage Playwright’s auto-waiting mechanisms to reduce flakiness and improve test stability.
  • Monitor test execution times and optimize tests to minimize the impact on your development workflow.
  • Regularly review and update your test suite to ensure it remains relevant and efficient as your application evolves.

Seeking help and resources from the Playwright Community

It offers a wealth of resources and support to help with your migration:

  • Playwright documentation: Comprehensive guides and API references for understanding Playwright’s features and capabilities.
  • GitHub repository: The official Playwright GitHub repository is a valuable resource for finding solutions to common issues and tracking feature updates.
  • Community forums and chats: Engage with other Playwright users and maintainers through forums, Slack channels, or Stack Overflow to ask questions, share experiences, and learn best practices.

By leveraging these resources and following the tips and best practices outlined in this guide, you’ll be well-prepared to smoothly transition from Cypress to Playwright, ultimately benefiting from improved browser support, enhanced reliability, and a robust API for end-to-end testing.


Migrating from Cypress to Playwright is a strategic move that can enhance your end-to-end testing capabilities, thanks to Playwright’s improved browser support, reliability, and powerful API. In this guide, we’ve covered the essential steps and best practices for a successful migration:

  • Understanding the key differences and pros and cons of Cypress and Playwright.
  • Preparing for the migration by evaluating your test suite, identifying areas for improvement, and creating a migration plan.
  • Setting up Playwright by installing dependencies, configuring your project, and familiarizing yourself with the API.
  • Migrating test cases by rewriting them in Playwright syntax and adapting to the new test runner and assertion library.
  • Integrating Playwright into your development workflow with CI/CD pipeline integration, reporting and monitoring test results, and updating documentation and training team members.
  • Ensuring a smooth transition by troubleshooting common migration issues, maintaining test reliability and performance, and leveraging the Playwright community for support.

By following this comprehensive guide, you’ll be well-equipped to make a seamless transition from Cypress to Playwright, ultimately leading to more robust and reliable end-to-end testing for your web applications. We encourage you to share your experiences, challenges, and successes in the comments section below and ask any questions you may have. Your insights and inquiries will not only help you on your migration journey but also support others who are undertaking a similar transition. Together, we can learn and grow as a community of developers dedicated to ensuring the highest quality for our web applications.

Leave a Reply

Your email address will not be published. Required fields are marked *