---
title: How to Share a Playwright HTML Report With Your Team
slug: /blog/share-playwright-report-with-team
publishedAt: "2026-06-11"
updatedAt: "2026-10-30"
author: ott
description: "Playwright's default HTML report is a folder you can't just send. Generate one self-contained report file, then publish it behind company auth so the team opens a link instead of unzipping an artifact."
---

# How to Share a Playwright HTML Report With Your Team

Playwright's report is a folder, which is why nobody can just open the one you ran. Turn the run into a single self-contained HTML file, then publish it behind your company login so the team clicks a link instead of unzipping a CI artifact.

> **TL;DR:** The default Playwright HTML reporter writes a `playwright-report/` directory, not a file. You cannot attach it to a message or upload it anywhere useful. Produce a single self-contained report (a one-file reporter like `monocart-reporter` does this), then ask your agent to publish it to Display. You get a URL gated to your company email. No GitHub Pages, no zip-and-pray, no per-report hosting bill.

---

## Why sharing a Playwright report is annoying

Run the tests and Playwright writes `playwright-report/index.html` plus a `data/` folder of traces, screenshots, and attachments. Locally, `npx playwright show-report` spins up a server and it all works.

The trouble starts the moment someone else needs to see it. The report is a directory, so:

- **Attaching it** means zipping the folder. The recipient downloads the zip, unzips it, finds `index.html`, and opens it from disk, where the trace viewer and some attachments break because the browser blocks local file access.
- **CI artifacts** keep the folder intact, but only people with access to the CI run can download it, and they still have to unzip and open it themselves.
- **GitHub Pages** can host the folder, but a public Pages site exposes your test names, selectors, and screenshots to anyone, and a private one needs every viewer to have repo access.
- **A dedicated report host** solves the folder problem, but it's another tool to wire in and pay for per run.

The failing test happened an hour ago. The engineer who can fix it still hasn't seen the report.

---

## Step 1: Produce one self-contained report file

A single self-contained report is the safe shape to publish with Display, and the default Playwright reporter doesn't give you one. The fix is a reporter that emits a single self-contained `report.html` with the trace data inlined.

[`monocart-reporter`](https://www.npmjs.com/package/monocart-reporter) is the common choice. Add it as a reporter in your Playwright config:

```ts
// playwright.config.ts
import { defineConfig } from '@playwright/test';

export default defineConfig({
  reporter: [
    ['monocart-reporter', {
      name: 'E2E Report',
      outputFile: './report/index.html',
    }],
  ],
});
```

Run the suite as usual:

```bash
npx playwright test
# writes ./report/index.html (one self-contained file)
```

The output is a single HTML file with the test tree, timings, error diffs, and trace data embedded. Move it to another folder, open it, and confirm the failures and attachments still load. If they do, it's ready to publish.

If you'd rather keep the stock Playwright reporter, you can still get one file by merging the run into a single blob and rendering it, but a single-file reporter is the shortest path from "tests ran" to "one file to share."

---

## Step 2: Publish it behind company auth

[Display](https://app.display.dev), the AI docs workspace that's open to all agents and people, puts that file at a URL that never changes behind your identity provider. Viewers authenticate with the Google Workspace or Microsoft 365 account they already use.

Connect your agent to Display once, through MCP, the CLI or the API. Then ask your agent:

> "Publish ./report/index.html to Display for everyone at my company, named e2e-report."

Your agent returns a link such as `https://yourcompany.dsp.so/e2e-report`.

Paste the URL in the failing build's Slack thread or the bug ticket. Anyone with a company email opens it and reads the full report (failures, retries, traces) with nothing to download or unzip. People outside your domain hit a login wall, so your selectors and screenshots stay internal.

The link is [gated](/blog/what-is-gated-publishing) to your company, and it stays the same. Teammates comment on a failure right on the page, and your agent can read those comments when it works on the fix. Viewers and commenters are free, so the whole team can open the report without a hosting bill that scales with how many people look.

---

## How the options compare

| Method                       | One link to open      | Private to your company | Viewer needs an account  | Extra tooling       |
| ---------------------------- | --------------------- | ----------------------- | ------------------------ | ------------------- |
| Zip the folder               | No (download + unzip) | Yes                     | No                       | No                  |
| CI artifact                  | No (download + unzip) | Yes                     | Yes (CI access)          | No                  |
| GitHub Pages                 | Yes                   | Only on private repos   | Yes (GitHub) for private | Pages setup         |
| Dedicated report host        | Yes                   | Varies                  | Varies                   | Per-run hosting     |
| Single-file report + Display | Yes                   | Yes (SSO)               | Company email only       | A one-file reporter |

---

## Publishing it straight from CI

The natural place to publish is the same job that runs the tests. After the suite produces `report/index.html`, a CI step publishes it with an API key instead of an interactive login. The job calls Display's REST API, or an agent publishes the file. Run the step with `if: always()`.

The `if: always()` is the important part: you most want the report when the suite fails. Each run can publish to a fresh URL. Or it can publish the new version to a stable link. Then a single "latest E2E report" link always shows the most recent run. The full pattern, including how to store the API key, is in [publishing HTML from GitHub Actions](/blog/github-actions-publish-html-authenticated).

---

## Where this fits

A test report is one case of a recurring problem. A tool produces rich HTML, and the people who need to read it work somewhere else. The same flow publishes [Jupyter notebooks](/blog/share-jupyter-notebook-with-team), [Quarto and R Markdown reports](/blog/share-quarto-report-with-team), and [data dashboards](/data-dashboards) behind the same company login.

---

## FAQ

**Q: Why can't I just publish the default `playwright-report/` folder?**

Display publishes docs and files, and a single self-contained report is the safest shape to open reliably. Generate a single self-contained report (a one-file reporter like `monocart-reporter` produces one `report.html`) and publish that.

**Q: Does the trace viewer still work in a published report?**

It works when the trace data is inlined into the single HTML file, which is what a self-contained report does. The fragile path is opening an unzipped default report from your local disk, where the browser blocks the file access the trace viewer needs. A published, served file doesn't have that problem.

**Q: Will the report be public?**

No. Access is gated by your company email domain, so your test names, selectors, and screenshots stay internal. On Solo and higher plans, people sign in with Google Workspace or Microsoft 365. Someone without a company email hits a login wall.

**Q: How is this different from a report-hosting service like Gaffer?**

A dedicated report host uploads and serves the report, billed around test runs. Display serves a single report file behind your company SSO at a flat price. The report sits in a Space next to every other doc your team publishes (dashboards, notebooks, proposals), and you and your agents can search them all.

**Q: Can I keep one stable "latest report" URL?**

Yes. Ask your agent to publish each run to the same link. The URL stays the same and always shows the most recent run, which is handy to pin in a CI channel.
