Custom reporters

Taqwright has no reporting layer of its own — it forwards the reporter option straight to Playwright's runner. So any Playwright reporter works unchanged, including a fully custom one you write. And because taqwright's device trace and screen recording are attached as standard Playwright attachments, your custom reporter can pull them into whatever report format you want.

Overview

When you run npx taqwright test, taqwright locates your taqwright.config.ts and spawns Playwright's own runner against it. defineConfig() returns a real Playwright TestConfig and passes reporter through verbatim — there is no whitelist, no wrapper, and no forced reporter. The built-in presets (list, html, json, junit, blob, github, …) are covered in Running & debugging → Reports. This page is about writing your own.

Writing a custom reporter

Implement the Reporter interface from @playwright/test/reporter. The three hooks you'll almost always want are onBegin, onTestEnd, and onEnd:

Copyimport type {
  Reporter, FullConfig, Suite, TestCase, TestResult, FullResult,
} from '@playwright/test/reporter';

export default class MyReporter implements Reporter {
  private rows: Array<Record<string, unknown>> = [];

  onBegin(config: FullConfig, suite: Suite) {
    console.log(`Starting ${suite.allTests().length} tests`);
  }

  onTestEnd(test: TestCase, result: TestResult) {
    this.rows.push({
      title: test.titlePath().join(' › '),
      project: test.parent.project()?.name,
      status: result.status,                 // 'passed' | 'failed' | 'timedOut' | 'skipped'
      durationMs: result.duration,
      retry: result.retry,
      error: result.error?.message,
      attachments: result.attachments.map((a) => a.name),
    });
  }

  async onEnd(result: FullResult) {
    const fs = await import('node:fs/promises');
    await fs.writeFile(
      'reports/custom.json',
      JSON.stringify({ status: result.status, tests: this.rows }, null, 2),
    );
    console.log(`Custom report written — overall: ${result.status}`);
  }
}

Every Playwright reporter hook is available (onStdOut, onStdErr, onStepBegin/onStepEnd, onError, printsToStdio, …). taqwright doesn't intercept any of them — your reporter sees exactly what a Playwright web reporter would: standard TestCase / TestResult objects, the Playwright-managed result.status, and the full attachment list.

Wiring it in

Reference the reporter module from taqwright.config.ts. Use the array tuple form — [modulePath] or [modulePath, options] — and stack it alongside any built-ins:

Copyimport { defineConfig, Platform } from 'taqwright';

export default defineConfig({
  reporter: [
    ['list'],                                  // keep a console reporter
    ['./reporters/my-reporter.ts'],            // your custom reporter
    ['./reporters/my-reporter.ts', { slackWebhook: process.env.SLACK_URL }],
  ],
  projects: [ /* ... */ ],
});

You can also pass it per-run on the CLI — taqwright test forwards --reporter to Playwright:

Copynpx taqwright test --reporter=./reporters/my-reporter.ts
# or stack with a preset:
npx taqwright test --reporter=list,./reporters/my-reporter.ts

Consuming taqwright's trace & video

This is the part unique to taqwright. When trace or video is enabled, taqwright writes its artifacts as standard Playwright attachments on the test result — so a custom reporter reads them straight off result.attachments, no taqwright import required:

They are deliberately not named trace / video — Playwright's own HTML report reserves those names for its browser .zip traces and recordings. Each attachment is the normal Playwright shape ({ name, contentType, path }, occasionally body), so you can copy, embed, or link them however your report needs:

CopyonTestEnd(test: TestCase, result: TestResult) {
  for (const att of result.attachments) {
    if (att.name === 'taqwright-trace' && att.path) {
      // e.g. copy next to your report and link it
      this.traceFor[test.id] = att.path;            // .../trace.html (text/html)
    }
    if (att.name === 'taqwright-video' && att.path) {
      this.videoFor[test.id] = att.path;            // .../screen.mp4 (video/mp4)
    }
  }
}

TypeScript & dependencies

• A .ts reporter is fine. Playwright transpiles the reporter module the same way it transpiles your taqwright.config.ts — no separate build step needed.
• Type imports come from @playwright/test/reporter. taqwright doesn't re-export the reporter types. @playwright/test is a direct dependency of taqwright, so it already resolves in your project's node_modules; for clean, version-pinned editor types add it explicitly: npm i -D @playwright/test.
• Nothing taqwright-specific is required to write the reporter — it's a pure Playwright reporter. taqwright only affects what is in the attachments, not the reporter contract.