Setting Up Euriqa with GitHub Actions in 5 Minutes

What You Will Have at the End

By the end of this guide, every Playwright test run in your GitHub Actions pipeline will automatically report to Euriqa. You will have a centralized dashboard showing pass rates, failure details, screenshots, traces, and flakiness tracking across every commit and pull request. The whole setup takes about five minutes.

No changes to your test files. No complex infrastructure. One npm package, a few lines of config, and two secrets in GitHub.

Prerequisites

Before you start, make sure you have the following:

• A GitHub repository with an existing Playwright test suite
• A Node.js project with Playwright installed (@playwright/test)
• An Euriqa account — the free Hobby tier works fine for this. Sign up at app.euriqa.dev

That is everything. Let's go.

Step 1: Create Your Euriqa Project

Head to app.euriqa.dev and sign up for an account. The onboarding wizard will walk you through the initial setup.

First, create a team. This is the organizational container for your projects — name it after your company, department, or squad. Next, create your first project. A project maps to a single test suite or repository. Give it a name that matches your repo so you can find it quickly in the dashboard.

Once the project is created, Euriqa generates two values for you: an API key and a project ID. Copy both of these. You will need them in the next steps.

The API key authenticates your CI pipeline with Euriqa. The project ID tells the reporter which project to send results to. Keep the API key private — it goes into your GitHub secrets, not into your code.

Step 2: Install the Reporter

In your project directory, install the Euriqa Playwright reporter:

npm install @euriqa/euriqa-playwright --save-dev

That is it. One package. No peer dependencies to worry about, no additional binaries to install. The reporter hooks into Playwright's built-in reporter API and handles everything else — serialization, upload, artifact streaming — internally.

Step 3: Configure playwright.config.ts

Open your playwright.config.ts and update it with the Euriqa reporter and some recommended settings:

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

export default defineConfig({
  use: {
    screenshot: 'only-on-failure',
    video: 'retain-on-failure',
    trace: 'on-first-retry',
  },
  retries: 2,
  reporter: [
    [
      '@euriqa/euriqa-playwright',
      {
        apiKey: process.env.EURIQA_API_KEY,
        projectId: process.env.EURIQA_PROJECT_ID,
        uploadScreenshots: true,
        uploadVideos: true,
        uploadTraces: true,
      },
    ],
    ['html'], // Keep your local reporter too
  ],
})

Here is what each setting does and why we recommend it:

• screenshot: 'only-on-failure' captures a screenshot when a test fails. This gives you visual context for debugging without adding overhead to passing tests. Euriqa displays these screenshots inline in the dashboard.

• video: 'retain-on-failure' records video of every test but only saves the recording when a test fails. Videos are invaluable for understanding timing-dependent failures — you can see exactly what the browser rendered and when.

• trace: 'on-first-retry' generates a Playwright trace on the first retry attempt. Traces give you the full picture: every action, network request, DOM snapshot, and console log. Generating them only on retries is a good balance between data richness and performance.

• retries: 2 enables Playwright's built-in retry mechanism. When a test fails, Playwright re-runs it up to two more times. Euriqa tracks per-attempt results, so you can see whether a test passed on retry (indicating flakiness) or failed consistently (indicating a real regression).

• The Euriqa reporter runs alongside any other reporters. You do not have to give up your HTML report. Add as many reporters as you need — Euriqa does not interfere with them.

Step 4: Add Secrets to GitHub

Your API key and project ID should never be committed to source control. Instead, store them as GitHub Actions secrets.

Go to your repository on GitHub. Navigate to Settings then Secrets and variables then Actions. Click New repository secret and add two secrets:

• Name: EURIQA_API_KEY — Value: the API key from step 1
• Name: EURIQA_PROJECT_ID — Value: the project ID from step 1

These secrets will be available to your GitHub Actions workflows as environment variables but will never appear in logs or be exposed to forks.

Step 5: Update Your GitHub Actions Workflow

Create or update your workflow file to run Playwright tests with the Euriqa environment variables. Here is a complete example:

name: Playwright Tests
on:
  push:
    branches: [main]
  pull_request:
    branches: [main]

jobs:
  test:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - uses: actions/setup-node@v4
        with:
          node-version: 20
      - run: npm ci
      - run: npx playwright install --with-deps
      - name: Run Playwright tests
        run: npx playwright test
        env:
          EURIQA_API_KEY: ${{ secrets.EURIQA_API_KEY }}
          EURIQA_PROJECT_ID: ${{ secrets.EURIQA_PROJECT_ID }}

Euriqa auto-detects GitHub Actions. When the reporter runs inside a GitHub Actions environment, it automatically picks up the branch name, commit SHA, commit message, build URL, and pull request number. You do not need to pass any of these values manually — the reporter reads them from the environment variables that GitHub Actions provides.

This means every run in your dashboard is tagged with the exact commit and branch that triggered it. You can filter by branch, click through to the GitHub commit, and trace any failure back to the code change that caused it.

Step 6: Push and Verify

Commit your config changes and push to your repository:

git add playwright.config.ts .github/workflows/playwright.yml
git commit -m "Add Euriqa reporter to Playwright config"
git push

Watch the GitHub Actions run in your repository. When it finishes — or even while it is still running if real-time streaming is active — open your Euriqa dashboard at app.euriqa.dev.

You should see the test run appear with full details: pass and fail counts, duration, branch, and commit information. Click into any test to see step-level results. For failures, you will find screenshots, videos, and traces viewable directly in the browser. No zip files to download. No artifacts to hunt for.

From this point forward, every push to main and every pull request will automatically report results to Euriqa. Your team has a single source of truth for test health.

Bonus: Sharded Setup for Large Suites

If your test suite has hundreds of tests and you want to split execution across multiple machines, Playwright's sharding feature works seamlessly with Euriqa.

Update your workflow to use a matrix strategy:

jobs:
  test:
    runs-on: ubuntu-latest
    strategy:
      matrix:
        shard: [1/4, 2/4, 3/4, 4/4]
    steps:
      - uses: actions/checkout@v4
      - uses: actions/setup-node@v4
        with:
          node-version: 20
      - run: npm ci
      - run: npx playwright install --with-deps
      - name: Run Playwright tests
        run: npx playwright test --shard=${{ matrix.shard }}
        env:
          EURIQA_API_KEY: ${{ secrets.EURIQA_API_KEY }}
          EURIQA_PROJECT_ID: ${{ secrets.EURIQA_PROJECT_ID }}

This runs your suite in four parallel jobs, each handling a quarter of the tests. The important part: Euriqa automatically reconstructs the complete picture from all shards. You see one unified run in the dashboard, not four separate ones. Pass rates, flakiness scores, and duration metrics are calculated across the full suite, regardless of how many shards you use.

For teams with large suites, sharding can cut your CI wall time from 30 minutes to under 10. Combined with Euriqa's shard-aware reporting, you get speed without losing visibility.

Five Minutes Well Spent

That is the entire setup. One npm package, a config update, two secrets, and a workflow file. Your team now has centralized test reporting with full artifact access, flakiness tracking, and historical analytics — on every commit, automatically.

No more digging through CI logs. No more downloading HTML report artifacts. No more asking teammates if a test is known-flaky.

Full test visibility in five minutes. Sign up free at app.euriqa.dev.