Docker image reference

mcr.microsoft.com/playwright:v1.50.0-jammy, decoded

One tag, four facts most pages skip: it is Ubuntu 22.04, it ships Node.js 22, its browsers live in /ms-playwright, and they are frozen to Playwright 1.50.0. Get any of those wrong against your own project and your CI run dies before the first test. Here is the whole picture, plus how a generated Playwright suite runs inside it without a single change.

M
Matthew Diakonov
7 min read

Direct answer (verified 2026-06-19)

mcr.microsoft.com/playwright:v1.50.0-jammy is Microsoft's official Playwright 1.50.0 Docker image built on Ubuntu 22.04 LTS (Jammy). It includes Node.js 22 and the Chromium, Firefox, and WebKit browsers preinstalled at /ms-playwright. Pull it from the Microsoft Container Registry:

terminal
docker pull mcr.microsoft.com/playwright:v1.50.0-jammy

Confirmed present on the registry tag list at mcr.microsoft.com/v2/playwright/tags/list on 2026-06-19, with multi-arch variants -jammy-amd64 and -jammy-arm64. Playwright 1.50.0 was released on 2025-01-23.

What is actually inside the tag

The Dockerfile that builds this image is open and pinned to the v1.50.0 tag of the Playwright repository. It starts from FROM ubuntu:jammy, installs Node.js from the NodeSource node_22.x repository, then runs playwright-core install --with-deps to download every browser engine plus its system libraries. Nothing about the version is left to chance at runtime.

Contents of v1.50.0-jammy

  • Ubuntu 22.04 LTS (Jammy Jellyfish) as the base OS
  • Node.js 22 (from the NodeSource node_22.x repository)
  • Chromium, Firefox, and WebKit preinstalled at /ms-playwright
  • All Linux system dependencies the browsers need to launch headless
  • PLAYWRIGHT_BROWSERS_PATH set to /ms-playwright with 777 permissions
  • Browsers pinned to exactly Playwright 1.50.0 (released 2025-01-23)
Base OSUbuntu 22.04 LTS (Jammy Jellyfish)
Node.js22.x (NodeSource node_22.x)
BrowsersChromium, Firefox, WebKit
Browser path/ms-playwright (env PLAYWRIGHT_BROWSERS_PATH)
Playwright1.50.0 (released 2025-01-23)
Architecturesamd64, arm64 (multi-arch manifest)

The one rule that decides whether your run passes

The most common failure with this image has nothing to do with the image being broken. It is a version mismatch. The browsers in /ms-playwright carry a build number tied to Playwright 1.50.0. When you run npx playwright test, the runner computes the path it expects from whatever @playwright/test version your package.json resolves to, and then looks for that exact folder. If your project is on 1.52 but the image is on 1.50.0, the folder it wants was never downloaded.

How the version match decides whether your tests run

1

package.json declares @playwright/test

The version here is the source of truth for which browser build number the test runner will look for.

2

Image tag fixes the browser build

v1.50.0-jammy baked browsers for 1.50.0 into /ms-playwright. Nothing else is downloaded at runtime.

3

Runner resolves /ms-playwright/<engine>-<build>

npx playwright test computes the expected path from your installed version, then looks for that exact folder.

4

Match: browsers launch. Mismatch: launch fails

If the versions line up, Chromium/Firefox/WebKit start instantly. If not, you get "Executable doesn't exist".

When it goes wrong, the error names the path the runner could not find:

mismatch error
browserType.launch: Executable doesn't exist at
  /ms-playwright/chromium-XXXX/chrome-linux/chrome
╔════════════════════════════════════════════════════════════╗
║ Looks like Playwright Test or Playwright was just installed  ║
║ or updated.                                                  ║
╚════════════════════════════════════════════════════════════╝

The official documentation states the rule directly: if the Playwright version in your Docker image does not match the version in your project, Playwright will be unable to locate browser executables. The fix is to make the two agree, in either direction.

Pin one to match the other

Image is v1.50.0-jammy but package.json resolves @playwright/test to ^1.52. The runner looks for a 1.52 browser build that the image never downloaded.

  • Image: v1.50.0-jammy
  • package.json: @playwright/test ^1.52
  • Result: Executable doesn't exist at /ms-playwright/...

One more thing the version-pinning guides rarely mention: 1.50.0 was a short-lived patch. It shipped on 2025-01-23 and was replaced by 1.50.1 on 2025-01-31. The registry carries v1.50.1-jammy too. If you are staying on the 1.50 line, prefer the patch tag and set @playwright/test to 1.50.1 so the pair still matches.

Running real Playwright specs in this image, generated or hand-written

The reason teams reach for this image is to stop fighting browser installs in CI. Whatever produced your .spec.ts files, if they are standard @playwright/test specs, they run here with one command. That is the practical upside of generating real Playwright code instead of a proprietary format: there is no separate runtime to install, no cloud step in the middle, and nothing that needs translating before it can run in the official image.

Assrt crawls your app, proposes scenarios, and writes ordinary Playwright spec files into your repo. Because the output is just Playwright, the CI job is the same job you would write for hand-authored tests:

.github/workflows/e2e.yml
jobs:
  e2e:
    runs-on: ubuntu-latest
    container:
      image: mcr.microsoft.com/playwright:v1.50.0-jammy
    steps:
      - uses: actions/checkout@v4
      - run: npm ci                 # installs @playwright/test 1.50.x
      - run: npx playwright test    # browsers already live in /ms-playwright

Note what is absent: no npx playwright install step. The browsers are already in the image, so adding that line would only download a redundant copy. As long as npm ci resolves @playwright/test to the 1.50.x line, the run is green.

If you want to generate the specs in the first place, Assrt is a single command and the tests it writes are yours to read, edit, and commit:

terminal
npx @m13v/assrt discover https://your-app.com

The generated files are plain Playwright. They do not depend on Assrt to run, so dropping Assrt later leaves you with a working suite. That is the difference between a tool that writes code into your repo and a closed runtime that holds your tests hostage. For the deeper version of this argument, see how AI-generated Playwright E2E tests actually read.

Why a proprietary test format cannot just drop into this image

This official image is built for one thing: running @playwright/test against the three engines it preinstalled. A tool that records tests as its own YAML or stores them behind a hosted runner does not benefit from any of that. Its tests cannot execute with npx playwright test, so the preinstalled browsers at /ms-playwright, the multi-arch manifest, and the version-pinning story are all irrelevant to it. You end up paying for a separate execution environment instead of using the free, official one that already matches your Playwright version.

Generating standard Playwright code keeps you inside the ecosystem this image was designed for. The same files run on your laptop with npx playwright test, in this container in CI, and on any other Playwright-compatible runner, with no vendor in the path. Assrt is open-source and free, so there is no per-seat or per-run cost layered on top of the official image you are already using.

Want your CI suite to run in the official Playwright image?

Book a call and we will walk through generating standard Playwright specs that run in mcr.microsoft.com/playwright with zero lock-in.

Frequently asked questions

What is mcr.microsoft.com/playwright:v1.50.0-jammy?

It is Microsoft's official Docker image for Playwright version 1.50.0, built on Ubuntu 22.04 LTS (the Jammy Jellyfish release, which is what the -jammy suffix means). It ships Node.js 22 and all three Playwright browser engines (Chromium, Firefox, and WebKit) preinstalled into /ms-playwright along with their Linux system dependencies. The tag is published on the Microsoft Container Registry, not Docker Hub, so you pull it from mcr.microsoft.com directly. As of 2026-06-19 the tag is still present on the registry alongside architecture-specific variants v1.50.0-jammy-amd64 and v1.50.0-jammy-arm64.

What is the difference between -jammy and -noble?

Both are Ubuntu base images. -jammy is Ubuntu 22.04 LTS and -noble is Ubuntu 24.04 LTS. For Playwright 1.50.0 the plain tag v1.50.0 resolves to the same default base the Playwright team chose for that release; the -jammy and -noble suffixes let you pin the exact Ubuntu version regardless of which one becomes the default later. If your CI runner or your app's runtime libraries expect glibc and system packages from 22.04, choose -jammy. If you need 24.04, choose -noble. The Playwright version inside both is identical (1.50.0); only the OS layer differs.

Why do my tests fail with "Executable doesn't exist at /ms-playwright/..."?

That error means the Playwright version in your project does not match the browsers baked into the image. The image installs browsers for exactly Playwright 1.50.0 into /ms-playwright, and the path includes a build number tied to that version (for example /ms-playwright/chromium-XXXX/chrome-linux/chrome). When your package.json pulls @playwright/test 1.52 or 1.55, the test runner looks for a different build number that was never downloaded, and launch fails. The official docs state it plainly: if the Playwright version in your Docker image does not match the version in your project, Playwright will be unable to locate browser executables. Fix it by setting @playwright/test to 1.50.x, or by switching to the image tag that matches the version you already use.

Is v1.50.0-jammy the latest patch of 1.50?

No. Playwright 1.50.0 was published on 2025-01-23 and was superseded by 1.50.1 on 2025-01-31, eight days later. The image tag v1.50.1-jammy exists on the registry. If you are pinning to the 1.50 line and want the bug fixes from the patch, pin to v1.50.1-jammy and set @playwright/test to 1.50.1 so the versions still match. v1.50.0-jammy remains useful when you need a byte-for-byte reproducible build of the original release.

Can I run AI-generated Playwright tests inside this image?

Yes, with no special handling, because the test files are standard @playwright/test specs. Assrt generates real Playwright code, not a proprietary YAML or a closed runtime, so a generated tests/checkout.spec.ts runs under npx playwright test inside mcr.microsoft.com/playwright:v1.50.0-jammy exactly like a hand-written spec. The only requirement is the same version-match rule that applies to every Playwright project: your package.json @playwright/test must be on the 1.50.x line to match the browsers in the image.

Do I need to run npx playwright install inside this image?

No, and you should not. The browsers are already present at /ms-playwright and PLAYWRIGHT_BROWSERS_PATH is set to that path inside the image. Running npx playwright install again would download a second copy, bloat your layer, and possibly fetch a build number that does not match the system dependencies the image installed. Just run npx playwright test. The whole point of the official image is that the browser install step is already done and cached.

Does the image support Apple Silicon and ARM CI runners?

Yes. The registry publishes v1.50.0-jammy-amd64 and v1.50.0-jammy-arm64, and the multi-arch v1.50.0-jammy manifest resolves to the right one for your platform automatically. That means the same tag works on an Intel GitHub Actions runner and on an arm64 runner or an M-series laptop, and Docker pulls the matching architecture without you specifying it.

What user does the image run as?

By default the container processes run as root, and the browser directory at /ms-playwright is created with 777 permissions so that any user you switch to can still read the browser binaries. If your CI requires a non-root user, you can add a USER directive in a derived Dockerfile; the 777 permission on /ms-playwright is specifically there so that a non-root user can still launch the browsers.

Generate standard Playwright specs that run unchanged in mcr.microsoft.com/playwright:v1.50.0-jammy.

assrtOpen-source AI testing framework
© 2026 Assrt. MIT License.

How did this page land for you?

React to reveal totals

Comments ()

Leave a comment to see what others are saying.

Public and anonymous. No signup.