# Find rage clicks and dead clicks on your site

> Find rage clicks and dead clicks using session replay, inspect UI freeze frames, and catch user frustration before it hurts conversions.

**Rage clicks happen when a visitor clicks an unresponsive element repeatedly in frustration, while dead clicks occur when someone clicks an element that produces no reaction at all.** Both signals highlight broken layouts, frozen JavaScript, or misleading visual cues that cause visitors to drop off. With thelastapi, you can track these behaviors automatically using session replay, inspect reconstructed frame pictures of the exact elements clicked, and catch spikes before they damage conversions.

This guide explains how to identify rage clicks and dead clicks across your pages, inspect what visitors experienced, and triage broken interactions with automated health checks.

## What are rage clicks and dead clicks?

Visitors interact with your site based on expectations. When those expectations fail, their clicking pattern changes:

- **Rage clicks:** A visitor clicks the exact same button or link multiple times in rapid succession. This pattern typically signals that a checkout button failed to display a loading state, a script crashed silently on submit, or a navigation link failed to fire.
- **Dead clicks:** A visitor clicks an element expecting an action, but the element is completely inert. Common examples include plain text styled like a hyperlink, an image with an icon that fails to open a preview modal, or an inactive accordion tab.

Both patterns signal broken user experience. Rather than waiting for a visitor to file a support ticket or abandon a cart, you can isolate these friction points automatically from your recorded sessions.

## Turn on session replay for your project

Every project on thelastapi includes privacy-first web analytics by default. Analytics tracks pageviews, sources, countries, and custom events without cookies or stored IP addresses. To capture click frustration, you need the `replay` resource, which records session interactions directly in the browser.

You can add replay to a project when you create it:

```bash
vibiz init acme-site --resources analytics,replay
```

Or add it to an existing project at any time:

```bash
vibiz add replay
```

Once the replay resource is attached, the standard analytics script tag starts recording sessions automatically with no extra code required:

```html
<script defer src="https://thelastapi.dev/v1/script.js" data-key="vz_pk_123"></script>
```

A site hosted anywhere can use session replay. Add your domain using `vibiz domains add example.com --elsewhere` and paste the tag from `vibiz analytics snippet` before `</head>` on every page. Events and replay chunks are accepted only from your project's configured domains.

Session replay is privacy-first by design. Masking happens in the visitor's browser before data ever uploads:
- Text that looks like an email address, phone number, card number, or IBAN is masked automatically.
- Password, payment card, and one-time-code fields are never recorded under any circumstances.
- Standard form fields are recorded as typed, but you can block any field by adding `data-vibiz-sensitive` to the markup.
- You can obscure entire layout regions by adding `data-vibiz-mask`.

For projects subject to consent requirements in the UK or EU, you can set `require_consent: true` in your replay configuration. Recording then pauses until your code explicitly calls `vibiz('replay', 'start')`. You can adjust settings via the API using `PATCH /v1/projects/:id/resources/replay` with fields like `sample_rate`, `require_consent`, `trigger_events`, `unmask_pages`, `retention_days`, and `record_css_rules`. Full configuration options are detailed in the [Analytics and replay docs](https://thelastapi.dev/docs/analytics).

## Filter sessions with rage clicks and dead clicks

Recording every visitor is only useful if you can quickly surface sessions that went wrong. You do not need to watch hours of video to find broken buttons. The `vibiz replays` CLI command lets you filter recorded sessions directly:

```bash
# Find sessions with rage clicks over the last 7 days
vibiz replays --rage --period 7d

# Find sessions with dead clicks over the last 7 days
vibiz replays --dead --period 7d

# Narrow results down to a specific page path
vibiz replays --rage --path /checkout --period 7d
```

Each command returns a list of matching replays, the pages visited, and the specific failure signals recorded. When you identify an interesting session, retrieve its signals and a private playback link:

```bash
vibiz replay rpl_123
```

The output gives you the session timeline, showing exactly when the visitor encountered errors or started clicking repeatedly. If you work with an AI agent in Cursor, Claude Code, or Codex, tools like `vibiz_replay_insights` and `vibiz_replay_detail` return the same structured timeline. You can also explore how to review site performance with an assistant in [Ask your agent "how is my site doing?" and get a real answer](https://thelastapi.dev/blog/ask-agent-how-is-my-site-doing), or read more about lightweight recordings in [Session replay for a small site: masked, cheap and useful](https://thelastapi.dev/blog/session-replay-small-site).

## Inspect the broken UI with visual frames

Watching full video replays can be slow when you just need to know which button failed. thelastapi provides visual replay frames: static screenshots of the page reconstructed at key moments in the session.

When a rage or dead click occurs, the frame captures the page rebuilt as a static document, sized to the visitor's exact viewport. The clicked element is outlined, and the pointer position is marked with a dot.

You can inspect these moments with the CLI:

```bash
# Save PNG screenshots of rage clicks and errors
vibiz replays frames rpl_123 --moments rage_click,error --out ./frames
```

You can also fetch frames using plain HTTP:

```bash
curl "https://thelastapi.dev/v1/replays/rpl_123/frames?moments=rage_click" \
  -H "Authorization: Bearer $VIBIZ_API_KEY"
```

The response returns an array of frames:

```json
{
  "frames": [
    {
      "kind": "rage_click",
      "offset_ms": 14200,
      "page": "/pricing",
      "label": "button.checkout-btn",
      "viewport": { "width": 390, "height": 844 },
      "status": "ready",
      "image": {
        "url": "https://thelastapi.dev/v1/files/frame_abc.png",
        "expires_at": "2026-11-12T13:00:00.000Z"
      }
    }
  ]
}
```

Because frames respect masking, any sensitive or masked text remains obscured with bullets or asterisks, and blocked regions show as striped boxes. Image URLs work for one hour. Listing the frames again gives fresh links at no extra cost.

## Catch frustration spikes in Mission Control

Checking replays manually after a deploy is good practice, but background health checks ensure you never miss an unexpected surge in broken clicks.

Mission Control runs automated checks across all your projects roughly once an hour. The **Errors** check monitors user experience using replay data:

| Check signal | Warning trigger (last 24 hours) | Failing trigger (last 24 hours) |
| --- | --- | --- |
| **Rage clicks** | 5 or more sessions with rage clicks | — |
| **Dead clicks** | 10 or more sessions with dead clicks | — |
| **JavaScript errors** | 3 or more sessions with errors | 10 or more sessions (3x normal daily baseline) |

If a bad script push or layout regression breaks a button across your site, Mission Control flags the project with an amber warning dot.

You can check current project health from your terminal:

```bash
# Check every business, worst first
vibiz health

# Run health checks again immediately
vibiz health run
```

If the Errors check shows a warning, the check output names the issue and provides a direct link to the affected session replays in the console. Learn more about automated monitoring in [Know when your site goes down, a deploy fails or sales stop](https://thelastapi.dev/blog/know-when-your-site-goes-down) and the [Mission Control and health checks docs](https://thelastapi.dev/docs/mission-control).

## Pricing and limits

Analytics events and replay session recording are recorded at $0. Replay storage costs $0.023 per GB-month, billed with the default margin (+20% today, shown as `billed_usd` in usage).

Key limits to keep in mind:
- **Retention:** Replay data is retained for 30 days by default (configurable from 1 to 90 days via `retention_days`).
- **Sampling:** Sessions record with a default `sample_rate` of 1. If you lower the sample rate, sessions upload only when triggered by a JavaScript error, a rage click, a dead click, or configured trigger events.
- **Chunk sizes:** Replay data uploads in chunks up to 1 MB.
- **Frames:** The `/frames` endpoint returns up to 6 pictures by default and at most 12 per call (`?limit=`).

## Next steps

To start tracking rage clicks on your app, run `vibiz add replay` in your project folder, or deploy your frontend with the analytics snippet included. Then run `vibiz replays --rage --period 7d` to inspect where your visitors are getting stuck.

## Frequently asked questions

### What triggers a rage click in session replay?

A rage click is triggered when a visitor clicks the same element repeatedly in rapid succession, indicating that the interface is not responding to their actions.

### Are passwords and credit card numbers visible in session replays?

No. Password, payment card, and one-time-code fields are never recorded, and text resembling emails, phone numbers, or card numbers is masked in the browser before upload.

### How do I view screenshots of dead clicks without watching a full recording?

Run `vibiz replays frames <id> --moments dead_click --out frames` to generate and save static screenshots of the exact moments and elements clicked.

### When does Mission Control warn about click frustration?

Mission Control flags an amber warning when a project records 5 or more sessions with rage clicks or 10 or more sessions with dead clicks within a 24-hour period.

---

Published 2026-11-15 · https://thelastapi.dev/blog/find-rage-clicks-dead-clicks
