> For the complete documentation index, see [llms.txt](https://docs.coupler.io/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://docs.coupler.io/sources/category/other/bugsnag.md).

# Bugsnag

Pull Bugsnag error data, projects, and organizations into Google Sheets or BigQuery. Monitor app stability trends without leaving your spreadsheet.

Bugsnag is an error monitoring and stability management platform that captures exceptions, crashes, and performance issues across your web and mobile applications. It helps engineering teams detect, diagnose, and resolve errors faster by providing detailed context around every event.

Connecting Bugsnag to Coupler.io lets you pull your error data into spreadsheets, dashboards, or AI tools — so your whole team can act on stability trends without logging into Bugsnag directly.

## Why connect Bugsnag to Coupler.io?

* **Centralize error reporting** — combine Bugsnag errors and events with data from other tools (e.g., deployment logs, project management) in one place
* **Track stability over time** — export error trends and release data to Google Sheets or BigQuery for historical analysis
* **Share insights without Bugsnag access** — send error summaries to stakeholders via Google Sheets, Looker Studio, or even AI tools like ChatGPT or Gemini
* **Automate reporting** — schedule recurring exports so your dashboards always reflect the latest error data

## Prerequisites

* A Bugsnag account (any plan that includes API access)
* A Bugsnag **Personal Auth Token** — find this under your account settings at **My Account → Personal auth token**
* Organization Admin or project-level access depending on which entities you want to export

## Quick start

{% hint style="success" %}
Start with the **Errors** or **Events** entity — these give you the most actionable data for stability analysis right away.
{% endhint %}

### How to connect

{% stepper %}
{% step %}
**Create a new data flow in Coupler.io.** From your Coupler.io dashboard, click **Add data flow** and search for **Bugsnag** as your source.
{% endstep %}

{% step %}
**Enter your Bugsnag API key.** Paste your Personal Auth Token into the API key field. You can find this token in Bugsnag under **My Account → Personal auth token**.
{% endstep %}

{% step %}
**Select an entity.** Choose what data you want to pull — for example, **Errors**, **Events**, **Releases**, or any other entity listed below.
{% endstep %}

{% step %}
**Set a start date.** Use the date picker to define how far back Coupler.io should fetch data.
{% endstep %}

{% step %}
**Choose your destination.** Pick where you want your data to land — Google Sheets, Excel, BigQuery, Looker Studio, or an AI destination like Claude, ChatGPT, or Gemini.
{% endstep %}

{% step %}
**Run the data flow.** Click **Run** to execute a manual sync and confirm your data is coming through correctly.
{% endstep %}
{% endstepper %}

## Available entities

| Entity                         | Description                                                |
| ------------------------------ | ---------------------------------------------------------- |
| Organizations                  | Organizations available in your Bugsnag account            |
| Projects                       | Projects within your organizations for tracking errors     |
| Errors                         | Error occurrences and exceptions captured by Bugsnag       |
| Events                         | Individual error events and their details                  |
| Pivots                         | Pivot table data for analyzing error patterns              |
| Releases                       | Application releases and deployment information            |
| Saved searches                 | Saved search queries for filtering error data              |
| Saved searches usage summaries | Usage statistics for saved searches                        |
| Collaborators                  | Team members with access to your projects                  |
| Teams                          | Teams organized within your Bugsnag account                |
| Event fields                   | Custom fields and metadata associated with error events    |
| Trace fields                   | Custom fields for error trace data                         |
| Supported integrations         | Available integrations that can be configured with Bugsnag |

## Bugsnag data overview

Bugsnag exposes data across error monitoring, team management, and release tracking. Through Coupler.io, you can export any of these entities and combine them to build a complete picture of your application's stability.

## Entities and what they contain

| Entity                         | What you get                                                                      |
| ------------------------------ | --------------------------------------------------------------------------------- |
| Organizations                  | Organization ID, name, slug, billing plan, creation date                          |
| Projects                       | Project name, type, API key, language, error count, URL                           |
| Errors                         | Error class, message, severity, status, first/last seen timestamps, event count   |
| Events                         | Full event payload — stack trace, device info, user info, breadcrumbs, timestamps |
| Pivots                         | Aggregated breakdowns of error data by dimension (browser, OS, app version, etc.) |
| Releases                       | App version, release stage, build tool, source map status, release timestamp      |
| Saved searches                 | Search name, query filters, associated project                                    |
| Saved searches usage summaries | Search ID, query count, last used timestamp                                       |
| Collaborators                  | User name, email, role, two-factor status, project membership                     |
| Teams                          | Team name, ID, project assignments, member count                                  |
| Event fields                   | Custom field names and values attached to error events                            |
| Trace fields                   | Custom field names and values for trace-level data                                |
| Supported integrations         | Integration name, type, configuration status                                      |

## Key metrics and dimensions

#### Error-level metrics

| Metric      | Description                                                 |
| ----------- | ----------------------------------------------------------- |
| Event count | Total number of times an error has occurred                 |
| User count  | Number of unique users affected by an error                 |
| First seen  | Timestamp when the error was first captured                 |
| Last seen   | Timestamp of the most recent occurrence                     |
| Severity    | Error severity level (error, warning, info)                 |
| Status      | Current status of the error (open, fixed, ignored, snoozed) |

#### Event-level dimensions

| Dimension              | Description                                                |
| ---------------------- | ---------------------------------------------------------- |
| App version            | The release version of the app when the event occurred     |
| Release stage          | Environment label (production, staging, development, etc.) |
| OS name / version      | Operating system of the affected device or browser         |
| Browser name / version | Browser context for web errors                             |
| Country                | Country associated with the user session                   |
| User ID / email        | Identifies which user experienced the event                |
| Timestamp              | Exact date and time the event was captured                 |

#### Release metrics

| Metric               | Description                                        |
| -------------------- | -------------------------------------------------- |
| Sessions received    | Number of sessions recorded for this release       |
| Crashes received     | Number of crashes attributed to this release       |
| Unhandled error rate | Percentage of sessions that had an unhandled error |
| Release stage        | Which environment this release was deployed to     |

## Common metric combinations

* **Errors + Releases** — join these two entities to see which app versions introduced or resolved specific errors. Use Coupler.io's **Join** transformation to match on app version.
* **Events + Event fields** — combine raw events with custom metadata to filter by your own business-specific attributes (e.g., subscription tier, feature flag).
* **Errors (multiple projects)** — use **Append** to stack error data from multiple Bugsnag projects into a single table for cross-project stability reporting.
* **Pivots** — use pivot data to build aggregated views by OS, browser, or app version without processing raw events yourself.

## Use cases by role

{% tabs %}
{% tab title="Engineering" %}

* Monitor error rates by release to catch regressions immediately after deploys
* Join Errors and Releases to correlate crash spikes with specific app versions
* Export Events to BigQuery for long-term retention and custom SQL analysis
* Use Pivots to break down error frequency by OS or browser without manual grouping
  {% endtab %}

{% tab title="Product & QA" %}

* Track unhandled error rates across releases to measure stability improvements
* Export Errors to Google Sheets for sprint retrospectives and bug triage prioritization
* Monitor which user segments are most affected by using Event-level user dimensions
* Use Saved searches usage summaries to see which error queries your team relies on most
  {% endtab %}

{% tab title="Engineering Managers" %}

* Build Looker Studio dashboards showing error trends and resolution velocity over time
* Export Collaborators and Teams to audit project access and team assignments
* Send weekly error summaries to ChatGPT or Gemini for AI-generated stability reports
* Append data from multiple projects to compare stability across your product portfolio
  {% endtab %}
  {% endtabs %}

## Platform-specific notes

* The **Events** entity can return large volumes of data — set a narrow start date if you're pulling from a high-traffic project
* **Pivots** require a project context and return pre-aggregated data; they are not raw event records
* **Saved searches** and their usage summaries are project-scoped — you'll need to run separate data flows per project if you have many
* API access and available entities may vary depending on your Bugsnag plan; Enterprise plans have broader API access
* The **Personal Auth Token** grants access to all organizations and projects your Bugsnag user can see — use a dedicated service account token for production data flows

## Bugsnag common issues

### Connection issues

<details>

<summary>Authentication failed / invalid API key</summary>

Double-check that you're using your **Personal Auth Token** and not a project-level API key. These are different credentials in Bugsnag. Your Personal Auth Token is found under **My Account → Personal auth token** in the Bugsnag dashboard. If the token was recently regenerated, update it in your Coupler.io data flow settings.

</details>

<details>

<summary>Data flow connects but returns no data</summary>

This usually happens when the authenticated user doesn't have access to the selected project or organization. Verify that your Bugsnag account has at least viewer-level access to the project you're trying to export. Also check that your **start date** isn't set too far back for inactive projects, or too recent to capture existing data.

</details>

### Missing data

<details>

<summary>Errors or events from certain projects are missing</summary>

Coupler.io pulls data based on the organization and project your API token has access to. If a project belongs to a different organization that your user isn't a member of, it won't appear. Check your Bugsnag organization memberships and confirm the token belongs to a user with access to all relevant projects.

</details>

<details>

<summary>Start date doesn't seem to filter data correctly</summary>

Bugsnag's API uses the first-seen or event timestamp depending on the entity. For **Errors**, the date filter applies to the `first_seen` field. For **Events**, it applies to the event timestamp. If you're expecting errors that were first seen before your start date but are still active, they may not appear — adjust your start date accordingly.

</details>

<details>

<summary>Pivots entity returns empty results</summary>

Pivots require a specific project context and valid pivot dimensions configured in your Bugsnag account. If no pivot data is configured in the project, the entity will return empty. Confirm that your Bugsnag project has pivot data available by checking it directly in the Bugsnag dashboard.

</details>

### Permission errors

<details>

<summary>403 Forbidden when accessing Organizations or Collaborators</summary>

Some entities — including **Organizations**, **Collaborators**, and **Teams** — require Organization Admin permissions. If your Bugsnag user is only a project-level member, you'll get a 403 error for these entities. Either use an Admin account's token or limit your data flow to project-scoped entities like Errors and Events.

</details>

### Data discrepancies

<details>

<summary>Error counts in Coupler.io don't match the Bugsnag dashboard</summary>

The Bugsnag dashboard applies real-time filters (release stage, time range, custom filters) that may not match the parameters in your data flow. Make sure your start date and any project filters in Coupler.io align with the dashboard view you're comparing against. Also note that the **Errors** entity returns aggregate counts, not per-event totals — use **Events** for granular counts.

</details>

### Rate limits

<details>

<summary>Data flow fails or times out on large exports</summary>

Bugsnag enforces API rate limits that vary by plan. If you're exporting a large volume of **Events** from a high-traffic project, the request may hit rate limits or time out. Narrow your start date to reduce the volume per run, or split the export across multiple data flows using different projects as sources.

{% hint style="warning" %}
The **Events** entity is particularly sensitive to rate limits. Start with a short date range (e.g., 7 days) and expand gradually once you've confirmed the flow works.
{% endhint %}

</details>

## Bugsnag FAQ

<details>

<summary>What is the difference between the Errors and Events entities?</summary>

**Errors** are grouped occurrences of the same exception — Bugsnag deduplicates individual crashes into a single error record with aggregate stats (total count, unique users, first seen, last seen). **Events** are the individual, raw crash reports that make up those errors. Use Errors for trend analysis and dashboards; use Events when you need per-occurrence details like stack traces, device info, or user breadcrumbs.

</details>

<details>

<summary>Where do I find my Bugsnag API key?</summary>

You need your **Personal Auth Token**, not the project API key. Log into Bugsnag, click your avatar in the top right, go to **My Account**, and scroll to the **Personal auth token** section. The project API key (shown in project settings) is for SDK instrumentation and won't work with Coupler.io.

</details>

<details>

<summary>Can I pull data from multiple Bugsnag projects in one data flow?</summary>

Yes — add multiple sources within the same data flow, each pointing to a different project. Then use the **Append** transformation to combine them into a single output table. This is useful for cross-project stability reports or portfolio-level dashboards.

</details>

<details>

<summary>Why is my Events export so slow or timing out?</summary>

The Events entity returns raw, per-occurrence data which can be very large for active projects. Narrow your start date to a shorter window (start with 7 days) and confirm the flow works before expanding. Also check that your Bugsnag plan supports the API rate limits needed for bulk event exports.

{% hint style="info" %}
See [Common Issues](#bugsnag-common-issues) for more on rate limits and large export handling.
{% endhint %}

</details>

<details>

<summary>Can I use Bugsnag data with AI tools like ChatGPT or Gemini?</summary>

Yes. Coupler.io supports AI destinations including ChatGPT, Claude, Gemini, Perplexity, Cursor, and OpenClaw. You can route your Bugsnag Errors or Events data directly to these tools for AI-generated analysis — for example, asking an AI to summarize the top error trends or suggest fixes based on error messages.

</details>

<details>

<summary>What permissions does my Bugsnag account need?</summary>

It depends on which entities you're exporting. Project-scoped entities like Errors, Events, and Releases only require project member access. Organization-level entities — Organizations, Collaborators, and Teams — require **Organization Admin** permissions. If you're getting 403 errors, check your role in Bugsnag.

{% hint style="info" %}
See [Common Issues → Permission errors](#bugsnag-common-issues) for troubleshooting steps.
{% endhint %}

</details>

<details>

<summary>How do I track which app version caused a spike in errors?</summary>

Export both the **Errors** and **Releases** entities as separate sources in your data flow, then use Coupler.io's **Join** transformation to link them by app version. This lets you see error counts and severity alongside release metadata — including which release stage and build tool was used.

{% hint style="info" %}
See [Data Overview → Common metric combinations](#bugsnag-data-overview) for more on joining Bugsnag entities.
{% endhint %}

</details>

<details>

<summary>Does Coupler.io support incremental syncs for Bugsnag?</summary>

Coupler.io uses your configured start date to determine how far back to fetch data on each run. For ongoing refreshes, set a start date that reflects your desired lookback window. Each scheduled run will pull data from that date forward, keeping your destination up to date.

</details>


---

# Agent Instructions
This documentation is published with GitBook. GitBook is the documentation platform designed so that both humans and AI agents can read, navigate, and reason over technical content effectively. Learn more at gitbook.com.

## Querying This Documentation
If you need additional information that is not directly available in this page, you can query the documentation by asking a question.

Perform an HTTP GET request on the following URL with the `ask` and `goal` query parameters:

```
GET https://docs.coupler.io/sources/category/other/bugsnag.md?ask=<question>&goal=<user_goal>
```

`ask` is the immediate question: it should be specific, self-contained, and written in natural language.
`goal` is what the user is ultimately trying to achieve, the reason they need the answer. Sharing it helps GitBook give you a better, more relevant answer. A goal is most helpful when it describes the outcome the user wants rather than restating the question. For example, with `ask=how do I create an API token`, a goal like `automate deployments from our CI pipeline` lets GitBook tailor the answer to that use case.

The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.
