Menu

Mattering Automations Bugsnag integration

Connect Bugsnag to Mattering Automations: errors with the full workflow verb set, comments, events with complete stack traces, pivots and Event Fields, windowed error and project trends, the 30 day session stability trend, releases, projects and collaborators as workflow steps, authenticated with one personal auth token.

The Mattering Automations Bugsnag integration adds the Bugsnag Data Access API v2 to your automation canvas: list and filter a project's errors, change their workflow state one at a time or in bulk, comment on them, read individual events with full stack traces and metadata, fetch the latest occurrence of an error in one call, break an error or a project down by any Event Field with pivots, chart windowed error and project trends, read the 30 day session stability trend, list releases, and manage projects, organizations and collaborators.

The credential is a Bugsnag personal auth token, generated in Bugsnag under My account, then Personal auth tokens, and sent in an Authorization header with Bugsnag's literal token prefix rather than Bearer. One extra setting matters: Bugsnag documents a different base server URL per dashboard. Organizations that sign in at app.bugsnag.com use api.bugsnag.com, organizations on app.bugsnag.smartbear.com use api.bugsnag.smartbear.com, and an on-premise installation uses api.your-domain, so point the credential at the host that matches the dashboard you sign in at. Setup takes a few minutes, and this guide walks through each step and ends with the full node reference.

The safety modeling is stated on the nodes rather than buried. Of the 35 nodes, 23 read and 12 act, and five carry a destructive flag: Bugsnag: Delete Error, Bugsnag: Delete All Errors in Project, Bugsnag: Delete Event, Bugsnag: Delete Project, and Bugsnag: Remove Collaborator. Bugsnag documents deleting all errors in a project as an action that cannot be reversed, and it takes no filters, so there is no partial version of it. Two scope facts belong up front too. Bugsnag paginates with the Link response header only, so most listers cannot hand the next step a next-page URL and the right instrument there is a larger per_page plus tighter filters, with releases the exception because they expose an offset a workflow can walk. And Bugsnag's performance monitoring surface, spans and traces with their own field vocabulary, is a separate product area that this integration deliberately does not cover yet.

Before you start

  • A Bugsnag account you can sign in to, and a personal auth token generated under My account, then Personal auth tokens. Signing in is not on its own enough to guarantee API access: Bugsnag documents API error codes for a lapsed subscription, for an expired trial, and for a user with no available seat, and its pricing comparison lists the data export API as a plan feature with volume tiers, so check the account's plan and the seat of the user whose token you use. The token acts as your Bugsnag user: it reaches every organization your account belongs to and can do what you can do, no more and no less.
  • Knowing which dashboard your organization signs in at. Bugsnag documents a different base server URL for each one: app.bugsnag.com organizations use api.bugsnag.com, app.bugsnag.smartbear.com organizations use api.bugsnag.smartbear.com, and an on-premise installation uses api.your-domain. Point the credential at the host that matches the dashboard you sign in at, and check that value before you replace a token that looks broken.
  • At least one Bugsnag project to point the first workflows at. An empty account works too, since Bugsnag: Create Project can make one, but the error, event, pivot and trend nodes only get interesting once a project has data.
  • Bugsnag permissions that match the nodes you plan to run. The general rule is that a write the user's project role does not allow comes back as Bugsnag error code 40000, insufficient project role, rather than as a connector fault. Two nodes are documented more tightly than that: Bugsnag: Delete Project requires organization administrator, and Bugsnag: Update Project can be refused on the plan as well as on the role, since part of what it edits is a plan feature. Read nodes need nothing beyond access to the project.
  • A Mattering workspace with access to the Automations app.
  • Not required and not stored here: your project's notifier API key. That key configures your application's Bugsnag library so it can report crashes, and it is not an API credential. It shows up in the output of Bugsnag: Get Project and Bugsnag: Create Project, but it will not authenticate this integration.

Create your Bugsnag personal auth token

Mattering authenticates to Bugsnag with a personal auth token, sent on every request as an Authorization header carrying Bugsnag's literal token prefix, not Bearer, alongside the version header that pins the API to v2. There are no scopes to choose: the token inherits your Bugsnag user's access, across every organization your account belongs to. That makes setup short and makes the choice of which account creates the token the real decision. For an integration several people will build on, a token from a service account with only the project access it needs beats a token from whoever set it up first.

Sign in to Bugsnag and open My account, then Personal auth tokens.
Create a token, give it a name that says where it will be used, and copy it as soon as it is shown.
A personal auth token acts as your Bugsnag user. It can read and change every organization and project your account can reach, including deleting errors and projects if your permissions allow it. Never commit it to version control or paste it into a shared document, and revoke it from the same page if it leaks. Revoking invalidates it everywhere it is used, including this integration's credential.
Check which dashboard you signed in at before you leave Bugsnag. If the address bar says app.bugsnag.smartbear.com, you will need to set the API host to api.bugsnag.smartbear.com in the next section. If it says app.bugsnag.com, leave the host blank. An on-premise installation uses api.your-domain.

Connect Bugsnag to Mattering

In Mattering Automations, open Connectors and click Add Connector.
Choose Bugsnag from the list.
Click Create new credential, paste the token into Personal Auth Token, and save.
Fill API Host only if your organization signs in somewhere other than app.bugsnag.com: enter api.bugsnag.smartbear.com for app.bugsnag.smartbear.com, or api.your-domain for an on-premise installation. Leave it blank for app.bugsnag.com organizations. A dashboard domain is accepted here and mapped to the matching API host.
The credential is stored encrypted in Google Secret Manager and never appears in workflow logs.
Click Test Connection. Mattering lists the organizations the token can see, the cheapest authenticated read in the API and one that needs no project context, so a successful response proves the credential on its own. The result names the host it used, which is how you catch a credential pointed at a different host than the dashboard the token was created on.
Click Connect. All 35 Bugsnag nodes appear in your canvas palette.

Verify it works

After connecting, open any automation canvas and check the palette: a Bugsnag section should list the query and action nodes. Drop Bugsnag: List Organizations onto the canvas and run a test step. It is the integration's natural probe: it takes no parameters and returns a bare array, so the organization IDs sit at data[].id. Copy one, because the project and collaborator nodes ask for it.

Next, run Bugsnag: List Projects with that organization ID. It also returns a bare array, so project IDs sit at data[].id, and the project ID is the value every error, event, pivot, trend and release node needs. Then run Bugsnag: List Errors against a project with data to confirm the read path end to end: you should get error classes, messages, statuses and occurrence counts back, again at data[].

Two things to notice while you are here. Project-scoped nodes carry an optional organization field whose only job is to populate the project picker, and it is never sent to Bugsnag, so you can ignore it whenever you already have the project ID to paste. And every node in this verify path is read-only: it cannot reach the five destructive nodes or change a single error's state, so it is safe to re-run whenever you rotate the token.

Node reference

35 nodes, generated from the connector itself so this reference always matches what ships.

Read and query nodes 23

Bugsnag: Get Error

bugsnag_get_error

Fetch one error with its class, message, status, severity, occurrence and user counts, assignee, linked issues, grouping reason and release stages. Filters scope the counts and the first and last seen times to a window.

Bugsnag: Get Error Trend

bugsnag_get_error_trends

Occurrence counts for one error over a time window, bucketed for a histogram. Set the window with since and before, then choose EITHER buckets_count (split the window into that many equal buckets, up to 50) OR resolution (fixed bucket width of 1m, 5m, 30m, 2h or 12h, up to 2000 buckets). Each row carries its own from and to timestamps and an events_count, so the rows are directly chartable.

Bugsnag: Get Event

bugsnag_get_event

Fetch one event in full: exceptions with stack traces, threads, custom metadata, request details, app, device and user context, breadcrumbs and feature flags. Custom metadata keeps whatever casing the reporting library sent, so both snake_case and camelCase keys can appear.

Bugsnag: Get Latest Event on Error

bugsnag_get_latest_event

Fetch the most recent occurrence of an error as a full report, in one call and without paging a list first. The usual first step after an alert fires: get the freshest stack trace, request and user context for the error.

Bugsnag: Get Organization

bugsnag_get_organization

Fetch one organization: name, slug, billing contact emails, creator, and the API URLs for its projects and collaborators.

Bugsnag: Get Project

bugsnag_get_project

Fetch one project: name, framework type, notifier API key, release stages, grouping and discard settings, open and for-review error counts, and its dashboard URL.

Bugsnag: Get Project Stability Trend

bugsnag_get_stability_trend

Session stability for a project over the last 30 days, one point per UTC day for the project's primary release stage: total sessions, sessions that saw an unhandled error, users seen, and users who hit an unhandled error. Session stability is 1 minus unhandled_sessions_count over total_sessions_count. Returns HTTP 204 with no body when the project has no session data yet.

Bugsnag: Get Project Trend

bugsnag_get_project_trends

Event counts for a whole project over a time window, bucketed for a histogram. Set the window with since and before, then choose EITHER buckets_count (up to 50 equal buckets) OR resolution (1m, 5m, 30m, 2h or 12h, up to 2000 buckets). Filters narrow which events are counted, so this also answers questions like unhandled errors in production per hour.

Bugsnag: Get Release

bugsnag_get_release

Fetch one release: app version, version code or bundle version, build label and tool, builder, source control revision and commit URL, errors introduced and seen, and session and user counts for computing stability.

Bugsnag: List Collaborators

bugsnag_list_collaborators

List the people in an organization with their IDs, emails, admin flag, pending-invitation state and per-project roles. Returns a bare array. Search by name or email with q.

Bugsnag: List Error Comments

bugsnag_list_error_comments

List the comments on an error with their authors and timestamps. Returns a bare array. Comments are sortable by creation time only.

Bugsnag: List Error Events

bugsnag_list_error_events

List the individual occurrences grouped into one error, newest first. This is how an automation gets from an alert to the actual stack traces, users and devices affected. Returns a bare array. Set full_reports for complete event payloads.

Bugsnag: List Error Pivot Values

bugsnag_list_error_pivot_values

Break one error down along a single dimension and get the full ranked list: every value of the chosen Event Field with its event count, its share of the total, and when it was first and last seen. Answers which users, versions or devices an error actually hit. Returns a bare array.

Bugsnag: List Error Pivots

bugsnag_list_error_pivots

Summarize one error across every dimension Bugsnag tracks: for each Event Field, how many unique values it has and which top values account for the occurrences. This is the answer to which release stages, browsers, devices or users an error is concentrated in. Returns a bare array.

Bugsnag: List Errors

bugsnag_list_errors

List a project's errors: class, message, context, status, severity, occurrence and affected-user counts, first and last seen times, linked issues, and which release stages they happen in. Returns a bare array, so downstream paths start at data[]. Filter with since, before and the Event Field filters object, e.g. error.status eq open. Set histogram to add a trend sparkline to each error.

Bugsnag: List Event Fields

bugsnag_list_event_fields

List the Event Fields a project supports: the display IDs usable as filter keys and pivots, their human names, aliases, which comparison types (eq, ne) they accept, and whether each is a built-in field or a custom filter. Run this first to discover what the filters object on the error, event, pivot and trend nodes will accept for this project.

Bugsnag: List Organizations

bugsnag_list_organizations

List the organizations the authenticated token can see, with their IDs, slugs and creators. Returns a bare array, so downstream paths start at data[]. The cheapest authenticated read in this connector and the credential health check to run first: the organization ID from here feeds the project, collaborator and team nodes.

Bugsnag: List Project Collaborators

bugsnag_list_project_collaborators

List the people who have access to one project. This is the set an error can actually be assigned to, so it is the right list to pick from before Bugsnag: Update Error with the assign operation.

Bugsnag: List Project Events

bugsnag_list_project_events

List individual event occurrences across a whole project, newest first: which error each belongs to, when it was received, its exception class and message, severity, whether it was unhandled, and its release stage. Returns a bare array. Narrow it with since, before and the Event Field filters. Set full_reports for the complete event payload including metadata, request, device and user.

Bugsnag: List Project Pivot Values

bugsnag_list_project_pivot_values

Break a whole project down along one dimension: every value of the chosen Event Field with its event count, share of the total, and first and last seen times. The distribution question, e.g. how events split across releases or devices. Returns a bare array.

Bugsnag: List Project Pivots

bugsnag_list_project_pivots

Summarize a whole project across every dimension: for each Event Field, how many unique values it has and which top values account for the events. The project-wide view of where errors are concentrated. Returns a bare array.

Bugsnag: List Projects

bugsnag_list_projects

List an organization's projects with their IDs, slugs, framework types, notifier API keys, release stages and open error counts. Returns a bare array. The project ID from here feeds every error, event, pivot, trend and release node.

Bugsnag: List Releases

bugsnag_list_releases

List a project's releases, newest first: app version, build label, who or what built it, source control revision, how many errors it introduced and saw, and its session counts. The release-health read behind questions like whether the last deploy made things worse. Returns a bare array.

Action nodes 12

Bugsnag: Bulk Update Errors

bugsnag_bulk_update_errors

Apply one workflow operation to many errors at once: the same set as Bugsnag: Update Error (fix, open, ignore, snooze, assign, override_severity, create_issue, link_issue, unlink_issue, discard). The response echoes the operation and the resulting state of each error ID. Reversible with the inverse operation over the same IDs. Needs project owner or organization administrator permissions.

Bugsnag: Comment on Error

bugsnag_create_error_comment

Post a comment on an error as the token's user. The usual automation move is writing back what a workflow did: which deploy is suspected, which ticket was opened, who was paged. Reversible in the Bugsnag dashboard, which is where comment deletion lives.

Bugsnag: Create Project

bugsnag_create_project

Create a project in an organization and get back its notifier API key, which is what an app's Bugsnag library is configured with. Reversible with Bugsnag: Delete Project while the project is still empty.

Bugsnag: Delete All Errors in Project

bugsnag_delete_all_errors

DESTRUCTIVE: delete ALL error and event data in a project. The vendor documents this as an action that cannot be reversed. It takes no filters, so there is no partial version of it. Needs project owner or organization administrator permissions.

Bugsnag: Delete Error

bugsnag_delete_error

DESTRUCTIVE: delete one error and every event grouped into it. Its comments, assignment, linked issues and history go with it. If the same crash happens again it comes back as a NEW error with status open and no history. Needs project owner or organization administrator permissions.

Bugsnag: Delete Event

bugsnag_delete_event

DESTRUCTIVE: delete one event occurrence, including its stack trace, metadata and any user data captured with it. There is no undelete. The parent error survives with one fewer occurrence.

Bugsnag: Delete Project

bugsnag_delete_project

DESTRUCTIVE: delete a project along with every error and event in it. The notifier API key stops working, so any app still reporting to it goes dark. There is no undelete. Requires organization administrator permissions, and projects maintained by a third-party add-on cannot be deleted at all.

Bugsnag: Invite Collaborator

bugsnag_invite_collaborator

Invite someone to the organization by email. Bugsnag SENDS AN INVITATION EMAIL to the address, so point automated runs at a test address you own. Grant project access at the same time with project_ids or project_roles. Reversible with Bugsnag: Delete Collaborator.

Bugsnag: Remove Collaborator

bugsnag_delete_collaborator

DESTRUCTIVE: remove a person from the organization. They lose access to every project in it, and their team memberships and project roles are gone; re-adding them means a fresh invitation and rebuilding those grants. Errors they were assigned to become unassigned.

Bugsnag: Update Collaborator Permissions

bugsnag_update_collaborator_permissions

Change which projects a collaborator can reach, their role on each, and whether they administer the organization. project_ids REPLACES the access list, so read the current state with Bugsnag: List Collaborators first and send the full set. Reversible by writing the previous values back.

Bugsnag: Update Error

bugsnag_update_error

Change one error's workflow state. The operation field picks what happens: fix, open, ignore, snooze (with reopen_rules), assign (to assigned_collaborator_id, or blank to unassign), override_severity (with severity), create_issue, link_issue (with issue_url), unlink_issue, discard or undiscard. Every state has an inverse operation, so this is reversible. The operation named delete is NOT: use Bugsnag: Delete Error, which says so in its name. Needs project owner or organization administrator permissions.

Bugsnag: Update Project

bugsnag_update_project

Edit a project's name, grouping rules, discard rules and collaborator list. Only the fields you fill are sent. Array fields REPLACE their current contents, and collaborator_ids removes anyone not listed, so read the current values with Bugsnag: Get Project first. Changing grouping rules does not regroup existing errors. Reversible by writing the previous values back.

Using the integration

On the automation canvas

Bugsnag nodes chain with every other node. A scheduled workflow can run Bugsnag: List Errors with a short since window and an error status filter, pull context with Bugsnag: Get Latest Event on Error, open a task in Mattering Productivity, and then write the task link back with Bugsnag: Comment on Error so both sides point at each other. A weekly sweep can read Bugsnag: Get Project Stability Trend and Bugsnag: List Releases into a Mattering database and flag the deploy where stability dropped. The two IDs almost everything downstream needs come from Bugsnag: List Organizations and Bugsnag: List Projects.

From AI assistants over MCP

Every node speaks MCP, the open protocol for connecting AI assistants to tools, so Claude, ChatGPT, and Matter can drive the same surface with the same credential. A useful division of labour: give an assistant the read nodes and the reversible workflow verbs, and keep the deletes out of its reach. An agent can call Bugsnag: Get Latest Event on Error for the freshest stack trace, ask Bugsnag: List Error Pivot Values which app versions and devices the error concentrates in, then use Bugsnag: Update Error to assign it and Bugsnag: Comment on Error to record what it concluded, so its reasoning lands on the error rather than in a chat log.

Errors and the workflow verbs

Bugsnag: Update Error carries Bugsnag's whole workflow model behind one operation field: fix, open, ignore, snooze with reopen rules, assign to a collaborator or blank to unassign, override severity, create an issue, link or unlink an issue, discard and undiscard. Every one of those has an inverse, which is why the node is treated as reversible. The exception is the operation named delete, which the node's own description points away from: use Bugsnag: Delete Error, which is named for what it does and flagged destructive. Bugsnag: Bulk Update Errors applies a single operation across many error IDs and echoes the resulting state of each, and assignment should draw its target from Bugsnag: List Project Collaborators rather than the organization-wide list. Bugsnag does not reject an assignment to a collaborator who lacks access to the project: it returns success and leaves the error unassigned, and it behaves the same way for a collaborator who has not accepted their invitation, so an agent reading only the status code will believe it assigned something it did not. Pick the target from the project list and read the assignment back.

Filters and Event Fields, the query model to learn first

Bugsnag's query language is Event Fields, not free text. Run Bugsnag: List Event Fields against a project and you get the display IDs that are valid filter keys and pivot dimensions, their human names and aliases, and which comparison types they accept. Those keys feed the filters input on the error, event, pivot and trend nodes, for example error.status set to open, or an app version, release stage or device dimension. Alongside filters, every filtering node exposes since and before as fields of its own, which the connector sends as Bugsnag's documented event.since and event.before filter entries, and both accept Bugsnag's relative form as well as ISO 8601, which is what makes a scheduled workflow able to roll its own window. There is no free-text search on the error and event listers, by design: Bugsnag does not offer one there, and pretending otherwise would produce a search box that returns the same rows for every query.

Pivots, trends and stability

Three different questions, three different node families. Pivots answer where: Bugsnag: List Error Pivots and Bugsnag: List Project Pivots summarize across every dimension, and Bugsnag: List Error Pivot Values and Bugsnag: List Project Pivot Values return the full ranked list for one chosen dimension with counts, shares, and first and last seen times. Trends answer when: Bugsnag: Get Error Trend and Bugsnag: Get Project Trend bucket counts across a window, where you choose either buckets_count to split the window into equal buckets or resolution to fix the bucket width, and each row carries its own from and to plus an events_count, so rows are directly chartable and safe to add up across adjacent buckets. Stability answers how bad: Bugsnag: Get Project Stability Trend returns one point per UTC day for the last 30 days on the project's primary release stage, with total sessions, sessions that saw an unhandled error, users seen, and users who hit one. Note that the daily user counts are per-day figures and cannot be summed across days without double counting anyone active on more than one.

Pagination is Link-header only

Bugsnag paginates with the Link response header and reports the total in the X-Total-Count header rather than in a body field. The node output carries the parsed response body, so most listers cannot hand the next step a next-page URL, and every lister's description says so plainly instead of implying a cursor exists. Bugsnag: List Releases is the exception, because that endpoint takes an explicit offset a workflow can increment itself. Elsewhere the pattern is to raise per_page and narrow with filters rather than trying to page. What Bugsnag documents: 30 results per page by default, a custom page size of up to 100 on resources that allow it, with a lower maximum stated in that endpoint's own reference where one exists. Releases stay the documented exception at 1 to 10 per page with an offset, and their default is 5. If a workflow genuinely needs a long history, walk it by time window with since and before rather than by page.

The five destructive nodes, gated

Bugsnag: Delete All Errors in Project is the heaviest: it takes no filters, so there is no partial version of it, and Bugsnag documents it as an action that cannot be reversed. Bugsnag: Delete Error removes one error and the events grouped into it, and the same crash returning afterwards arrives as a new error with status Open rather than reopening the old one. Bugsnag: Delete Event removes a single occurrence. Bugsnag: Delete Project takes the project, and Bugsnag: Remove Collaborator takes a person's access to the organization. Neither has an undo button, and both have knock-on effects that Bugsnag does not spell out, such as an application still configured to report to a project that no longer exists: expect them rather than treat them as documented. The pattern for all five is the same: read the thing first, and put the delete behind a condition, an approval task, or a manual run rather than a bare trigger.

What stays off the canvas

Some of Bugsnag's API is deliberately not here, and none of it is missing because it cannot be built. Performance monitoring, spans, traces and their own trace field vocabulary, is a separate product surface large enough to deserve its own wave. Teams, SCIM user and group provisioning, saved searches, feature flags and configured integrations are deferred rather than half-built, which has one visible consequence: the team field on the error update nodes is free text, because this integration ships no team lister and pointing a picker at a node that does not exist would be worse. Account administration such as creating or deleting organizations and regenerating API keys and auth tokens is left out on purpose, since regenerating a notifier key silently stops an app reporting. And the GDPR and CCPA data request endpoints are asynchronous jobs with legal significance that deserve a deliberate design rather than a generic call.

Troubleshooting

Test Connection fails but the token is definitely correct
Check the host before you check the token. Bugsnag documents a different base server URL per dashboard: app.bugsnag.com is served by api.bugsnag.com, app.bugsnag.smartbear.com by api.bugsnag.smartbear.com, and an on-premise installation by api.your-domain. A perfectly valid token sent to a host other than the one its dashboard uses is rejected exactly like a bad one, which is why the test result names the host it called. Open the credential in Connectors, set API Host to match the dashboard you sign in at, and test again before you replace the token. If the failure mentions a connection or DNS problem rather than a rejection, the host value itself is malformed; a bare hostname is what belongs there.
Nodes return 401 or 403 after working fine
The token was revoked, or the user it belongs to lost access. Personal auth tokens carry their user's permissions, so an account that leaves the organization, or has its project access narrowed, takes the integration's reach with it, and the workflows that break will be the ones touching the projects that user can no longer see. Create a fresh token from My account, then Personal auth tokens, update the credential in Connectors, and run Test Connection. If only the write nodes fail while reads still work, this is a permissions problem rather than a token problem: Bugsnag answers a write the user's project role does not allow with error code 40000, insufficient project role. Project deletion is documented as organization administrator only, and a project update can be refused on the plan as well as on the role.
A node returns a Bugsnag error mentioning a subscription or account restriction
That is an account state, not a broken connector, and the codes in that family do not all mean the same thing. Bugsnag documents 30000 and 31000 for the account's subscription state, covering a lapsed subscription and an expired trial. 32000 is per-user: API access is restricted for that user because no seat is available, so a teammate can hit it on an account whose subscription is perfectly healthy. The nodes pass the response through rather than swallowing it, so the code and message land on the node output where a workflow can branch on them. Nothing in the credential or the node configuration will clear one of these: the subscription codes need the account's standing fixed with Bugsnag, and 32000 needs a seat for the user the token belongs to.
A list node only ever returns 30 rows
That is Bugsnag's default page size rather than the end of the data, and on most listers there is no next-page value for a workflow to follow: Bugsnag paginates with the Link response header, which the node output does not carry, and reports the total in the X-Total-Count header. Raise per_page on the node: Bugsnag documents a custom page size of up to 100 on resources that allow it, with a lower maximum stated in that endpoint's own reference where one exists. The releases lister is the documented exception, 1 to 10 per page with a default of 5 and an offset a workflow can walk. Better still, narrow instead of lengthening: set since and before, and add Event Field filters so the rows you want are the rows you get. For long histories, run the node repeatedly across successive time windows rather than trying to page.
The filters input seems to be ignored
Filters are a typed Event Field structure, not a search string, so a plain phrase either matches nothing meaningful or is rejected. Run Bugsnag: List Event Fields against the project first: it returns the display IDs that are valid filter keys, along with the comparison types each accepts. Build the filter from those keys, for example error.status with a value of open. A filter value can be a single value or several: Bugsnag combines several eq values with OR, and several ne values with AND. One silent drop is Bugsnag's own and no node can prevent it. When eq filters and ne filters are supplied for the same field, Bugsnag discards the ne filters to avoid an ambiguous combination, so read the rows you get back rather than assuming the exclusion held. A malformed filter is reported on the node output rather than dropped. Time bounds are the node's own since and before fields, which the connector sends as Bugsnag's documented event.since and event.before filter entries.
The project picker asks for an organization the node does not send
This is deliberate and inert. Bugsnag's only project lister is organization-scoped, while every project endpoint is addressed by project ID alone, so a project picker on a node like Bugsnag: List Errors would have no parent to resolve against and would sit empty forever. Project-scoped nodes therefore carry an optional organization field whose description says what it is for: it populates the project picker and is never sent to the API. The same trick appears on Bugsnag: Get Latest Event on Error, which carries an optional project field purely so the error picker has a parent. Both fields are optional, so if you already have the ID, paste it and ignore the picker.
An update wiped values I did not touch
Two nodes replace rather than merge, and both say so in their descriptions. On Bugsnag: Update Project, array fields replace their current contents, and the collaborator list removes anyone not included, so read the current state with Bugsnag: Get Project, carry those values into the update, and send the full set. On Bugsnag: Update Collaborator Permissions, the project list replaces the collaborator's access, so read it back from Bugsnag: List Collaborators first. Both are reversible by writing the previous values back, which is a good argument for capturing the read output in the run before the write step. One related non-bug: changing a project's grouping rules does not regroup existing errors, only future ones.
The stability trend comes back empty or ignores the dates I set
Both behaviours are the endpoint working as documented. Bugsnag: Get Project Stability Trend returns HTTP 204 with no body when the project has no session data yet, which happens when the application's Bugsnag library is not reporting sessions rather than errors. A 404 from the same node means the same thing rather than a wrong ID: Bugsnag documents it for a project that has seen no sessions from any release stage, so take an empty 204 and a 404 together as no session data yet, and check that the library reports sessions before you go hunting for the project ID. And it takes no date parameters at all: it always returns the trailing 30 UTC days for the project's primary release stage, so the window self-advances with the clock and cannot be pointed at a specific historical range. When you need a window you choose, use Bugsnag: Get Project Trend or Bugsnag: Get Error Trend, which take since and before along with either buckets_count or resolution. Those two reject a request that would exceed their documented bucket ceilings rather than quietly returning a clipped result, so a 400 from a trend node usually means the window and resolution combination asked for too many points.

Bugsnag is a trademark of its respective owner. Mattering uses platform names to identify the services these integrations connect to; no endorsement or affiliation is implied.

Start Free Explore our Products