# Fairlead Recorder for teams: The same report from every tester, filed to your issue tracker.

Canonical: https://fairleadhq.com/platform/recorder/

Updated: 2026-09-26
Publication state: published
Product version: connected-preview

Agent summary: Fairlead Recorder for teams is the Recorder extension signed in to a Fairlead project. The project sets the recording scope, redaction keys and storage policy for every tester. Reports are stored in the project's Data Plane, can be given a generated description, and are filed to Jira, GitHub or Azure DevOps through Bridge. Selected content is sanitized; screenshots, console messages and notes need review.

## Prerequisites

- Chromium-compatible browser
- A Fairlead account in a project an admin has set up

## Inputs

- A manual browser test session, recorded under the project's settings

## Outputs

- An issue in the project's tracker, with the tester's text and the screenshots they select
- The redacted report, stored in the project's Data Plane unless the project turns storage off

## Limitations

- Test management systems are not connected. Filing a test result to one is in research.
- Filing works with Jira, GitHub and Azure DevOps.
- A generated description needs the project's Data Plane. A project that turns storage off gets none.
- On the Fairlead cloud Data Plane, reports are stored on Fairlead-operated servers.
- Connected correlation headers can reach third-party request destinations; capture domain rules do not limit injection.

## Permissions

- Active-tab access for the page being recorded
- Browser debugging access while recording network and console activity

## Privacy

- Sensitive-value rules apply during capture and report assembly; they do not cover all content.
- Bridge handles issue commands and screenshot transfers to the tracker.


An admin sets recording and redaction once, in the project. Every tester follows it and files from the side panel, evidence attached.

Review captured content before sending it.

## Free. Forever.

The extension and its team features cost nothing. No plan, no trial, no seat fee.

[The Recorder on its own, without an account](https://fairleadhq.com/)

## One project setup reaches every tester.

An admin sets the recording scope, the redaction keys and the storage policy once, in the project. Each tester's extension receives them when it signs in, so the whole team captures and redacts the same way.

A signed-in tester cannot edit these settings from the extension. Changing them is a project change, made in one place.

What a tester's extension receives from the project. Sample values.

```text
project     checkout-web
record      shop.example, *.shop.example
network     api.shop.example
redact      authorization, set-cookie, session_token,
            customer.email, card_number
storage     Save recorded data in Data Plane: on
            Data Plane: Fairlead cloud
file to     Jira  SHOP
            GitHub  your-org/checkout-web
```

## Where each part goes

The project's settings come down to the extension when it signs in. Automatic redaction covers selected keys and structures; inspect the remaining content. While recording, the extension adds request IDs to the page's requests, third-party ones included, so your backend can log them. The issue text and chosen screenshots go through Bridge to your tracker. The report goes to your project's Data Plane, the service that stores reports and can write a description from one.

## Find a recorded request in your backend logs.

While recording, the extension sends `x-fairlead-reproduction-id` with intercepted requests. Optional issue and per-request identifiers help narrow the search when your application logs them.

Header injection is not restricted by the project's capture rules, so the identifiers also reach third-party requests. Recording on your own sends none.

[Configure and check correlation](https://fairleadhq.com/docs/recorder/session-correlation/)

## The issue comes with a way into your logs.

Every request the tester recorded carried `x-fairlead-reproduction-id` down to your backends. Log it, and a developer finds where that QA session entered your system, in traces and logs, instead of guessing from a screenshot.

- Reproduction ID: One per session, on every recorded request. Search traces and logs for it to find the session's entry points. It is kept in the stored report.
- Title and description: Written by the tester, or generated from the stored report and then edited before filing.
- The Fairlead block: The tester's reproduction notes, in a fenced block of their own. If an existing description conflicts, review it in the tracker before choosing append or replacement.
- Screenshots: The included images. Pixels are not automatically masked; inspect each image before submission.

Your services need to log the headers; that is a one-time setup. When the tester picks the issue before recording, requests also carry its key, so the issue number finds them too.

## What it files to today.

An admin connects the destination once, in Control Plane. Testers never enter tracker tokens.

- Jira: A new issue or an existing one, with the tester's text and the screenshots they select. [Filing an issue](https://fairleadhq.com/docs/recorder/issue-trackers/)
- GitHub: A new issue or an existing one, with the tester's text and the screenshots they select. [Filing an issue](https://fairleadhq.com/docs/recorder/issue-trackers/)
- Azure DevOps: A new issue or an existing one, with the tester's text and the screenshots they select. [Filing an issue](https://fairleadhq.com/docs/recorder/issue-trackers/)
- Test management: No direct connection yet. Attach the downloaded evidence to the case or run by hand. [Attaching evidence to a TMS](https://fairleadhq.com/docs/recorder/tms-evidence/)

## You choose where reports are kept.

The Data Plane is the service that stores your project's reports and writes descriptions from them. Each project names one, and where it runs is your choice.

- Run by Fairlead: The Fairlead cloud Data Plane. Reports are stored on Fairlead-operated servers.
- Run by you: A Data Plane your organization runs and enrols, inside your own infrastructure. Fairlead's servers never hold the report.
- Or not kept at all: A project can turn storage off. Nothing is sent to a Data Plane, and there is no generated description. Filing to the tracker still works.

## On your own or with your team

It is the same extension. The difference is whether it signs in to a project.

| | On your own | With your team |
| --- | --- | --- |
| Account | None | A Fairlead account in your team's project |
| Settings | Built in. Recording stays on the site you start on | Set by the project for every tester |
| Redaction | Built-in rules, plus manual review | Project rules, plus manual review |
| The report goes to | A file you download | Your project's Data Plane, unless storage is off |
| Filing an issue | You attach the file yourself | From the side panel, to Jira, GitHub or Azure DevOps |
| Written description | Not available | Generated from the stored report |
| Session ID in your logs | No headers sent | Identifiers sent during recording; backend logging required |

## Who made it

We are backend developers. For years we were on the other end of the handoff, across dozens of apps and millions of lines of code: a screenshot, a sentence, and no way to find the request in the traces and logs. We built the capture side of the answer. The reproduction ID exists because it is the thing we always wanted and never got.

Fairlead is a product of Allyx, Inc. The report covers what we need as backend developers. If your team's bar is different, a QA step or a field the report should carry, tell us: