Menu
Mattering Automations connector

A Rollbar MCP that understands Rollbar's three token scopes

Connect your Rollbar access tokens and 48 nodes land on the canvas: list and resolve items, read occurrences with their full payloads, report and track deploys, inspect code versions, run occurrence and resolution-time metrics, run asynchronous RQL queries, and manage projects, users, teams and invitations. Each node states which token it needs, so a scope mistake fails with an explanation rather than a bare 403.

48 ready-made nodes One credential to connect Works with Claude, ChatGPT, and Matter

What the Rollbar MCP connector does

The Rollbar connector for Mattering Automations is 48 nodes on Rollbar API v1, 31 that read and 17 that act. Items are the centre: list, get, find by occurrence uuid or per-project counter, and update to resolve, mute, assign or snooze. Under them sit occurrences with their full payloads, including a permanent delete. Around them sit deploy reporting and tracking, environments, code versions with per-release item statistics, occurrence and activated-item count reports, top active items, occurrence and resolution-time metrics, asynchronous RQL queries, and the account surface of projects, users, teams and invitations.

Every node speaks MCP, the open protocol for connecting AI assistants to tools, so Claude, ChatGPT, and any MCP-capable assistant can use them, alongside Matter, the AI assistant built into the platform. Rollbar also publishes an MCP server of its own, and it is worth naming rather than ignoring: it is a stdio server your AI tool runs directly, with nine tools covering list projects, item details, recent deployments, version performance, top items in the last 24 hours, item search, occurrences, session replay metadata, and item updates. If what you want is a coding assistant that can look up the error it just caused, use Rollbar's server. This connector is a different shape of the same access, and the differences are real: the nodes are workflow steps as well as assistant tools, so they run on a schedule or off a trigger with nobody present, chain with every other connector in one automation, hold the tokens once in a shared workspace store rather than in each developer's local config, cover a wider surface including RQL, the metrics and report families, environments, and the whole team and invitation surface, and flag the three destructive nodes so you can gate them.

One structural fact shapes everything here and is the main reason this connector exists in the shape it does. Rollbar scopes its access tokens, and one token does not cover the API. An ACCOUNT token, created in Account Settings, reaches projects, users, teams and invitations, and also reaches project data when a project id travels with the request. A PROJECT token, created inside a project, reaches only that project's items, occurrences, deploys, environments, versions, reports, metrics and RQL. A POST token carries the post_server_item scope and is the only thing allowed to report items or deploys, and Rollbar states that newly created project tokens can no longer combine post_server_item with other scopes. So the credential holds up to three fields, you fill in the ones you need, and every node declares which one it wants in its own description and picks it automatically at run time.

Three of the 48 nodes are destructive. Rollbar: Delete Occurrence is permanent in Rollbar's own words and asynchronous, so a read immediately afterwards can still return the row. Rollbar: Delete Project is permanent and takes the project's access tokens with it, which means any application still reporting to that project goes dark. Rollbar: Delete Team removes a team. Nothing else in the connector destroys data. One family is deliberately absent for safety rather than for scope: Rollbar's project access token management endpoints are not shipped, because the lister returns live token VALUES and the writes mint and revoke credentials, which would put working secrets into execution logs and downstream node inputs. This connector never reads or creates Rollbar tokens.

One connection, three surfaces

  • Visual automations. Drag Rollbar nodes onto the canvas and wire them to triggers, conditions, and other apps.
  • AI agents, yours or ours. These nodes speak MCP, the open protocol, so Claude, ChatGPT, and any MCP-capable assistant can use them, and Matter, the agent built into the platform, uses them natively.
  • The whole platform. Combine with native tasks, projects, and other connectors, no middleware in between.

Every Rollbar node, ready to drop on the canvas

48 nodes, generated from the connector itself so this list always matches what ships. Expand a category to browse.

Read and query nodes 31

Rollbar: Find Item

Find an item WITHOUT its system-wide ID: by the counter shown in a Rollbar item URL (.../items/456/), or by the UUID of any one of its occurrences, which is what a Rollbar SDK returns to your application when it reports an error. Fill exactly one of the two. This is the bridge from a user-visible reference to the item_id every other node wants. Needs a PROJECT read token, or an ACCOUNT read token with project_id filled.

Rollbar: Get Activated Item Counts

Counts of items newly seen or reactivated per day, as positional [unix_timestamp, count] pairs at data.result[]. This is the 'new problems appearing' signal, as opposed to Get Occurrence Counts which is raw volume. The window is always the most recent buckets: set how many with buckets (2 to 366), not when. Needs a PROJECT read token, or an ACCOUNT read token; project_id is required either way.

Rollbar: Get Code Version

Fetch what Rollbar knows about one code version in one environment: when it was first and last seen, who deployed it, its commits, and item counts split into new, repeated, reactivated and resolved by severity at data.result.item_stats. This is the release-quality read to run after a deploy. Needs a PROJECT read token, or an ACCOUNT read token with project_id filled.

Rollbar: Get Deploy

Fetch one deploy by its system-wide ID: environment, revision, status, rollback flag, comment and timings. Needs a PROJECT read token, or an ACCOUNT read token with project_id filled.

Rollbar: Get Invitation

Fetch one invitation: who it went to, which team, its status (pending, accepted, rejected or cancelled) and when it was redeemed. The polling read for an onboarding workflow. Needs an ACCOUNT read token.

Rollbar: Get Item

Fetch one item by its system-wide ID: title, level, status, assignee, environment, occurrence counts and timestamps. The item_id here is the `id` other API calls return, NOT the short counter in a Rollbar item URL - use Rollbar: Find Item for that. Needs a PROJECT read token, or an ACCOUNT read token with project_id filled.

Rollbar: Get Item Metrics

Time-to-resolution metrics for a named set of items: how long each took to resolve the first time and the most recent time, in seconds, at data.result.metrics[]. Items are named by their PROJECT COUNTER (the number in a Rollbar item URL), not by the system-wide item id. Needs a PROJECT read token, or an ACCOUNT read token with project_id filled.

Rollbar: Get Occurrence

Fetch one occurrence with its complete reported payload: stack trace, request, person, server, client and custom metadata under data.result.data. Needs a PROJECT read token, or an ACCOUNT read token with project_id filled.

Rollbar: Get Occurrence Counts

Occurrence counts over recent time buckets for a project, or for one item within it. Returns positional [unix_timestamp, count] pairs at data.result[], each covering [timestamp, timestamp + bucket_size - 1] in GMT. There is no start or end parameter: the report always covers the most recent buckets, so it self-advances and cannot be asked for a historical range. Needs a PROJECT read token, or an ACCOUNT read token; project_id is required either way.

Rollbar: Get Occurrence Metrics

Occurrence metrics over an explicit time window, grouped and aggregated however you ask: counts by item, environment, level, or distinct people and IP addresses. Rows come back at data.result.timepoints[], each with its own timestamp and a metrics_rows[] list of {field, value} pairs. This is the only read in the connector that takes real start and end timestamps. Needs a PROJECT read token, or an ACCOUNT read token with project_id filled.

Rollbar: Get Project

Fetch one project: name, status, account, creation and modification timestamps, and its settings including timezone, grouping configuration and encryption-at-rest state. Needs an ACCOUNT read token.

Rollbar: Get RQL Job

Check an RQL job's status: new, running, success, failed, cancelled or timed_out. Set expand to result to get the rows back in the same call once it has finished. Needs a PROJECT read token, or an ACCOUNT read token with project_id filled.

Rollbar: Get RQL Job Result

Read the rows a finished RQL job produced, at data.result.result.rows with their column names at data.result.result.columns, plus rowcount, execution time and any warnings. Returns nothing useful until the job's status is success. Needs a PROJECT read token, or an ACCOUNT read token with project_id filled.

Rollbar: Get Resolution Time Metrics

How long items took to resolve, bucketed over a time window, across one or more projects. Rows at data.result.data[] carry a timestamp and a ttr in seconds under the aggregation you chose (median by default). Needs an ACCOUNT read token: this report spans projects and a project token cannot reach it.

Rollbar: Get Team

Fetch one team: name, account and access level. Needs an ACCOUNT read token.

Rollbar: Get Top Active Items

The items generating the most occurrences in the last N hours, each with a 24-element hourly count sparkline at data.result[].counts. Ranked by severity then volume by default; set sort to occurrences to rank purely by count. This is the natural body of a daily 'what is on fire' digest. Needs a PROJECT read token, or an ACCOUNT read token; project_id is required either way.

Rollbar: Get User

Fetch one user as your account sees them: username, email and whether email notifications are enabled. Needs an ACCOUNT read token.

Rollbar: List Deploys

List a project's deploys, most recent first, in pages of 20, with revision, environment, status, who deployed and the start and finish times. Rows are at data.result.deploys[]. Needs a PROJECT read token, or an ACCOUNT read token with project_id filled.

Rollbar: List Environments

List the environments Rollbar has seen for a project, in pages of 20, at data.result.environments[]. Every environment filter elsewhere in this connector takes one of these names. Needs a PROJECT read token, or an ACCOUNT read token with project_id filled.

Rollbar: List Item Occurrences

List the occurrences of ONE item, newest first, in pages of 20. This is how you get from a grouped error to the actual stack traces, request data and affected people behind it. Needs a PROJECT read token, or an ACCOUNT read token with project_id filled.

Rollbar: List Items

List a project's items (grouped errors) with title, level, status, environment, first and last occurrence timestamps and total occurrence counts. Rows are at data.result.items[] and data.result.total_count carries the match count. Search titles with query and narrow with status, level and environment. Needs a PROJECT read token, or an ACCOUNT read token with project_id filled.

Rollbar: List Items in Code Version

List the items associated with one code version in one environment, split by what the version did to them: new, repeated, reactivated or resolved. Each row carries the occurrence and people counts WITHIN that version. The direct answer to 'what did this release break'. Needs a PROJECT read token, or an ACCOUNT read token with project_id filled.

Rollbar: List Occurrences

List a project's most recent occurrences, newest first, each with its full reported payload at data.result.instances[].data (stack trace, request, person, server and custom metadata). Page with page, or walk backwards with last_id. Needs a PROJECT read token, or an ACCOUNT read token with project_id filled.

Rollbar: List Projects

List every project in the account with its ID, name, status and settings, at data.result[]. Needs an ACCOUNT read token (Account Settings > Account Access Tokens) - a project token gets 403 here, which is the single most common Rollbar surprise. The project IDs from here feed every project-scoped node when you are working from an account token.

Rollbar: List RQL Jobs

List RQL jobs with their query text, status and timestamps at data.result[]. Useful for finding a job someone else ran and reusing its result. Needs a PROJECT read token, or an ACCOUNT read token with project_id filled.

Rollbar: List Team Invitations

List every invitation ever sent for a team at data.result[] - pending, accepted, rejected and cancelled alike - with the invited email, who sent it and when. Pages of 5000. Needs an ACCOUNT read token.

Rollbar: List Team Projects

List which projects a team is assigned to, as team_id and project_id pairs at data.result[]. Pair it with Rollbar: List Projects to turn those IDs into names. Needs an ACCOUNT read token.

Rollbar: List Team Users

List the members of one team, at data.result[], in pages of 5000. Needs an ACCOUNT read token.

Rollbar: List Teams

List the account's teams with their IDs, names and access levels, at data.result[]. Access level is the permission the team grants on its projects: standard, light (read and write but not all settings, API-only), view (read-only, API-only), or owner. Needs an ACCOUNT read token.

Rollbar: List User Projects

List the projects one user can reach, at data.result.projects[]. The access-review read: run it before changing someone's teams to see what they actually have today. Needs an ACCOUNT read token.

Rollbar: List Users

List the users in the account with their IDs, usernames and emails, at data.result.users[]. These IDs are what Rollbar: Update Item assigns to and what team membership nodes take. Needs an ACCOUNT read token.

Action nodes 17

Rollbar: Assign Team to Project

Give a team access to a project at the team's access level. This is how a new project gets its people in one call instead of per user. Needs an ACCOUNT write token. Reversible with Rollbar: Remove Team from Project.

Rollbar: Assign User to Team

Add an existing account user to a team, which grants them the team's access level on every project the team is assigned to. The user must already exist in the account - use Rollbar: Invite to Team for someone who does not. Needs an ACCOUNT write token. Reversible with Rollbar: Remove User from Team.

Rollbar: Cancel Invitation

Cancel a pending invitation so its link stops working. Reversible by inviting the address again with Rollbar: Invite to Team. This endpoint answers with a plain {"description": "Invitation cancelled"} rather than Rollbar's usual err/result envelope. Needs an ACCOUNT write token.

Rollbar: Cancel RQL Job

Cancel a running RQL job. Reversible in the sense that nothing is lost: submit the query again with Rollbar: Run RQL Query. Needs a PROJECT read token, or an ACCOUNT read token with project_id filled.

Rollbar: Create Project

Create a project in the account, optionally copying settings from an existing one. Note what this does NOT return: the project's access tokens. Rollbar mints them with the project, but this connector deliberately ships no token-reading node (a node whose output is a live secret would put that secret into execution logs), so collect the new project's tokens from the Rollbar UI. Needs an ACCOUNT write token. Reversible with Rollbar: Delete Project while the project is still empty.

Rollbar: Create Team

Create a team at one access level. The team grants that level on every project it is later assigned to, so choose it carefully: view is read-only and light is read plus write without full settings access, and both are API-only levels that do not appear in the UI picker. Needs an ACCOUNT write token. Reversible with Rollbar: Delete Team.

Rollbar: Delete Occurrence

DESTRUCTIVE: permanently delete one occurrence and its whole payload. The vendor states this makes it unavailable in both the Rollbar UI and the API, and there is no undelete. Deletion is asynchronous, so a read immediately afterwards may still succeed before it 404s. The legitimate use is scrubbing an occurrence that captured data it should not have. Needs a PROJECT token with the WRITE scope, or an ACCOUNT write token with project_id filled.

Rollbar: Delete Project

DESTRUCTIVE: permanently delete a project with every item and occurrence in it. The vendor documents no recovery path. Its access tokens stop working, so any application still reporting to that project goes dark and its errors are simply lost. Needs an ACCOUNT write token.

Rollbar: Delete Team

DESTRUCTIVE: permanently delete a team. Everyone in it loses the project access the team granted, and its project assignments and pending invitations go with it; rebuilding means recreating the team and re-adding every member and project by hand. Needs an ACCOUNT write token.

Rollbar: Invite to Team

Invite an email address to a team. Rollbar SENDS EMAIL: if the address already belongs to a Rollbar user they are added to the team immediately and notified, otherwise a signup invitation goes out. Point automated runs at an address you own. Needs an ACCOUNT write token. Reversible with Rollbar: Cancel Invitation while it is still pending, or with Rollbar: Remove User from Team once it is accepted.

Rollbar: Remove Team from Project

Take a team's access to a project away. Nothing is deleted and the team keeps its other projects, so this is reversible with Rollbar: Assign Team to Project. Note the vendor's own docs disagree about the token here: the assign page says an ACCOUNT write token and the remove page says a PROJECT write token. This node sends the account token, matching the rest of the team surface; if it is refused, retry with a project write token stored in the credential.

Rollbar: Remove User from Team

Remove a user from a team. They lose the access that team granted, but the user account itself is untouched and nothing is deleted, so this is reversible with Rollbar: Assign User to Team. Needs an ACCOUNT write token.

Rollbar: Report Deploy

Tell Rollbar a deploy happened, which is what makes 'errors introduced in this release' and resolved_in_version work. Needs the POST TOKEN field of the credential: a project token with the post_server_item scope, NOT the read/write token. Report status started before the deploy and update it afterwards with Rollbar: Update Deploy, or post the final status in one call.

Rollbar: Report Occurrence

Report an error, a crash or a message INTO Rollbar from a workflow, so a failure detected anywhere in an automation lands in the same inbox as your application's errors. Needs the POST TOKEN field of the credential: a project token with the post_server_item scope. Rollbar states post scopes cannot be combined with read/write on newly created tokens, so the token that reads your items cannot report to it. Maximum payload 1024 KB. Reversible only in the sense that the resulting item can be deleted or muted; the occurrence itself counts against your plan's event quota.

Rollbar: Run RQL Query

Submit an RQL (Rollbar Query Language) query as an asynchronous job and get back a job ID. RQL is SQL-like and reads your own occurrence data, so it answers questions the fixed report endpoints cannot. This node only STARTS the job: poll Rollbar: Get RQL Job until status is success, then read Rollbar: Get RQL Job Result. Needs a PROJECT read token, or an ACCOUNT read token with project_id filled - read scope, despite being a POST.

Rollbar: Update Deploy

Close out a deploy that was reported as started: set it to succeeded, failed or timed_out and add a comment. Rollbar rejects the change with HTTP 409 if the deploy's current status is anything other than started, so this is a one-way transition per deploy. Needs the POST TOKEN field of the credential (post_server_item scope) - the same token that reported the deploy, NOT the read/write token.

Rollbar: Update Item

Resolve, mute, reactivate, retitle, re-level, assign or snooze one item. Only the fields you fill are sent, and every change is reversible by writing the previous value back. Needs a PROJECT token with the WRITE scope (a read-only token gets 403 here), or an ACCOUNT write token with project_id filled. assigned_team_id is an Advanced/Enterprise feature and the snooze fields are paid-plan only.

Connecting Rollbar takes one credential

The wire format is one header and nothing else: X-Rollbar-Access-Token against Rollbar's single global host, with no region and no self-hosted variant, so the credential carries no host field. Rollbar also documents passing a token in the query string or a form body as supported by some endpoints but deprecated; this connector never does, because a token in a URL leaks into logs and proxies. The scoping is the part that needs explaining. Create an ACCOUNT access token under Account Settings, then Account Access Tokens: it reaches the account surface (projects, users, teams, invitations, resolution-time metrics) and also reaches project data when the node's project id is filled, which Rollbar's own changelog describes as passing the account token with a project id parameter. Create a PROJECT access token under Project, then Settings, then Project Access Tokens, with the read scope, plus write if you want to resolve or assign items: it reaches that one project's items, occurrences, deploys, environments, versions, reports, metrics and RQL. Create a POST token in the same place with the post_server_item scope: it is the only thing allowed to report an occurrence or a deploy, and Rollbar states that newly created project tokens cannot combine post_server_item with other scopes, so it has to be a separate token from the read one. Fill in the fields you need and leave the rest blank. The sharpest trap in the whole API is worth knowing before you build: UPDATING a deploy requires the post token rather than a read and write project token, which is documented on Rollbar's own update-a-deploy page, so a perfectly good project token gets 403 on that one node forever with no hint why. Each node's description says which token it needs, and where an account token is being used on a project endpoint the connector refuses locally when the project id is empty rather than spending a round trip on a guaranteed 403. On plans: Rollbar's pricing page lists a free plan at $0 with 5,000 occurrences and 1,000 sessions per month, and lists REST API access with the Terraform provider across every tier, so API access is not itself a paid gate. Two node-level gates are documented on Rollbar's own API reference pages rather than on the pricing page, so verify them against your account before designing around them: assigning a team on an item update is described there as an Advanced or Enterprise feature, and the snooze fields on an item update are described as paid-plan features.

1

Decide which tokens you need. Reading and resolving items in one project needs a PROJECT token with read and write. Anything touching projects, users or teams needs an ACCOUNT token. Reporting an occurrence or a deploy, or updating a deploy, needs a POST token.

2

Create them in Rollbar. Account tokens live under Account Settings, then Account Access Tokens. Project tokens and post tokens live under Project, then Settings, then Project Access Tokens.

3

In Mattering Automations, open Connectors, click Add Connector, choose Rollbar, and create a credential. Paste each token into its own field and leave the others blank.

4

Click Test Connection. Mattering tries the account token against Rollbar's project list and the project token against its item list, and reports which of them verified, so you can see exactly what this credential can reach. A post-only credential correctly fails the test, because a post token cannot read anything at all, and that is better learned here than inside a workflow.

5

All 48 Rollbar nodes appear in the canvas palette. Run Rollbar: List Projects (account token) or Rollbar: List Items (project token) first: their output feeds the project and item pickers on the rest of the connector.

Common uses for the Rollbar MCP

Triage that does not stay inside Rollbar

Rollbar: List Items is the node a schedule polls, with Rollbar's own free-text search over item titles available on the picker beside it, and Rollbar: Get Item pulls the detail. Rollbar: List Item Occurrences and Rollbar: Get Occurrence go down to the individual events with their full payloads. Then Rollbar: Update Item closes the loop: resolve, mute, assign, or change the level, so the state in Rollbar matches the state in whatever your team actually works from. Because these are workflow steps, the same run can open a Mattering task with the stack trace attached, post to a channel, and write a row that keeps a weekly count. Two Rollbar-specific details the nodes carry: assigning a team on an update is documented by Rollbar as an Advanced or Enterprise feature, and the snooze fields are documented as paid-plan ones.

Deploy tracking, and the question of what a release broke

Rollbar: Report Deploy tells Rollbar a release happened, and Rollbar: Update Deploy moves it to succeeded or failed afterwards. Both need the POST token, which is the trap worth repeating: updating a deploy requires post_server_item rather than write, per Rollbar's own documentation, so it will 403 on a read and write project token forever. The update is also a one-way transition and answers HTTP 409 unless the deploy is currently in the started state. On the reading side, Rollbar: List Deploys and Rollbar: Get Deploy show what shipped, and the pair worth building on is Rollbar: Get Code Version and Rollbar: List Items in Code Version: the first splits a release's items into new, repeated, reactivated and resolved by severity, and the second lists them, which is the direct answer to whether the last deploy made things worse.

Ask a real question with RQL

Rollbar: Run RQL Query submits a query and returns a job id, because RQL is asynchronous. Rollbar: Get RQL Job polls its status, Rollbar: Get RQL Job Result reads the rows, Rollbar: List RQL Jobs shows what is running, and Rollbar: Cancel RQL Job stops one. This is the surface that lets an agent answer a question nobody built a report for, which is exactly the kind of request people bring to an assistant, and the create step needs only the read scope despite being a POST. Build it as start, poll, then read, rather than assuming a result comes back with the submission.

Error volume and resolution time, on a schedule

Rollbar: Get Occurrence Counts and Rollbar: Get Activated Item Counts give the volume trend, Rollbar: Get Top Active Items ranks the noisiest items of the last day, and Rollbar: Get Occurrence Metrics and Rollbar: Get Item Metrics answer more precisely with your own aggregates and bucket width. Rollbar: Get Resolution Time Metrics spans projects and is the one that answers how long things actually take to fix. Two defaults will quietly change your chart if nobody mentions them, so the nodes do: the occurrence counts report defaults to a minimum level of error, which silently EXCLUDES warnings unless you lower it, and both metrics endpoints default their timezone to US Pacific rather than UTC, so day boundaries shift for anyone assuming otherwise.

Report an occurrence from a workflow

Rollbar: Report Occurrence sends an item to Rollbar from the workflow itself, which is how a batch job, a webhook handler built on the canvas, or a failing automation step can land in the same place as the rest of your errors rather than in a log nobody reads. It needs the POST token. Two limits are worth designing around: Rollbar caps the payload at 1024 KB and answers HTTP 413 above it, and reported occurrences consume your plan's monthly allowance, which Rollbar lists at 5,000 occurrences on the free plan. Send a fingerprint if the same automation can fail repeatedly, so the repeats group into one item instead of burning the allowance.

Project, team and invitation administration

The account half of the connector is what an organization running many Rollbar projects actually needs automated. Rollbar: List Projects, Rollbar: Get Project and Rollbar: Create Project manage projects. Rollbar: List Users, Rollbar: Get User and Rollbar: List User Projects answer who has access to what. Rollbar: Create Team, Rollbar: Assign User to Team, Rollbar: Remove User from Team, Rollbar: Assign Team to Project and Rollbar: Remove Team from Project keep membership in step with whatever your source of truth is, and Rollbar: Invite to Team, Rollbar: Get Invitation and Rollbar: Cancel Invitation cover onboarding. All of these need the ACCOUNT token. Note that inviting someone SENDS an email, that the invitation list returns every invite ever sent including accepted and cancelled ones, and that deleting a project is permanent and takes its access tokens with it, so anything still reporting to that project goes dark.

Example: A post-deploy health check that opens one task with the right context

Built on the Automations canvas in a few minutes, or described in plain language to Matter and built for you.

1

Trigger: your release pipeline calls a Mattering webhook when a deploy starts.

2

Rollbar: Report Deploy records the release in Rollbar with the revision and environment, using the POST token. When the pipeline reports back, Rollbar: Update Deploy moves it to succeeded or failed, which needs the same POST token rather than a write token and only works while the deploy is still in the started state.

3

A wait step gives the release time to generate real traffic.

4

Rollbar: Get Code Version reads the release back and returns its item statistics split into new, repeated, reactivated and resolved by severity, which is the cleanest single answer to whether this deploy made things worse.

5

A condition tests the new and reactivated counts. Inside the normal range, the run writes a row into a Mattering database and stops there.

6

Outside it, Rollbar: List Items in Code Version returns the items introduced by this release, and Rollbar: List Item Occurrences pulls a representative occurrence with its payload for the worst one.

7

Matter summarises what changed from the item titles and the occurrence payload, a Mattering task opens for the release owner with the summary and the Rollbar links attached, and Rollbar: Update Item assigns the worst item to the same person so the two systems agree.

Rollbar MCP questions, answered

What Rollbar operations are supported?

48 nodes on API v1: 31 read and 17 act. Items: list, get, find by occurrence uuid or per-project counter, update (resolve, mute, assign, level, snooze). Occurrences: list account-wide, list per item, get, delete, and report a new one. Reports and metrics: occurrence counts, activated item counts, top active items, occurrence metrics, item metrics, and resolution-time metrics. Deploys: list, get, report and update. Environments, code versions and the items in a code version. RQL: create, list, get, read result, cancel. Account: projects (list, get, create, delete), users (list, get, list a user's projects), teams (list, get, create, delete, list users, list projects, assign and remove users, assign and remove projects) and invitations (list, invite, get, cancel). Deliberately not shipped: project access token management, because those endpoints return live token values and creating a node whose output is a working secret is a disclosure rather than a feature; the notification rule surface, which is around 28 near-identical per-channel endpoints and would outweigh the rest of the connector; service links; session replay; GDPR person deletion; and source map upload, which is a multipart file upload.

Does this work with Claude, ChatGPT, or other AI assistants?

Yes. Mattering exposes these nodes over MCP, an open protocol for connecting AI assistants to tools, so any MCP-capable assistant, including Claude and ChatGPT, can connect to your workspace and use them. Matter, the assistant built into the platform, uses the same nodes natively. The same nodes also run as steps on an automation canvas, on a schedule or off a trigger, with nobody present.

Rollbar publishes its own MCP server. Why use this connector?

It does, and for a developer at a keyboard it is often the better answer. Rollbar's MCP server is a stdio server, meaning your AI tool runs it directly rather than you running a process or connecting over HTTP, and it exposes nine tools: list projects, item details, recent deployments, version performance, top items of the last 24 hours, item search, occurrences, session replay metadata, and item updates. If what you want is a coding assistant that can look up the error it just caused while you are writing the fix, use Rollbar's server. This connector is shaped for operations rather than for an editor. The nodes are workflow steps as well as assistant tools, so they run on a schedule or off a trigger with nobody present and chain with every other connector in one automation. The surface is wider: RQL queries, the whole reports and metrics family, environments, deploy reporting and updating, and the complete team, project and invitation administration surface. The tokens live once in a shared workspace credential store rather than in each developer's local configuration. And the three destructive nodes carry flags so a delete can sit behind a condition or an approval task. One thing Rollbar's server has that this connector does not: session replay, which is deliberately not shipped here because replays are recordings of real end users and the replay id has no lister behind it.

Why does the credential ask for three tokens?

Because Rollbar scopes tokens three ways and one token genuinely does not cover the API, so a single-field credential would be a promise the API cannot keep. An ACCOUNT token from Account Settings reaches projects, users, teams and invitations, and also reaches project data when the node's project id is filled. A PROJECT token from a project's settings reaches only that project's items, occurrences, deploys, environments, versions, reports, metrics and RQL. A POST token carrying post_server_item is the only thing allowed to report an occurrence or a deploy, and Rollbar states that newly created project tokens cannot combine post_server_item with other scopes, so the token that reads your items cannot report a deploy and the token that reports deploys cannot read anything. Fill in the fields you need and leave the rest blank. Every node names the token it wants in its description, and the connector picks per node rather than sending whatever is available and hoping.

Why do I get a 403 rather than a 401 when the token is wrong?

That is Rollbar's own behaviour: it answers 403 for a missing, invalid or mis-scoped token, with an error body rather than a 401. The practical consequence is that 403 is ambiguous on this API and has to be read against the node. If the node needs an ACCOUNT token and you only stored a project one, that is a wrong KIND of credential rather than a bad one, and the connector reports it that way instead of sending a request that is guaranteed to fail. If the node needs a PROJECT token and you are using an account token, fill the node's project id, because an account token is scoped by that parameter; the connector refuses locally when it is empty rather than spending a round trip. And if it is Rollbar: Update Deploy specifically, the answer is almost always the POST token: Rollbar documents that endpoint as requiring post_server_item rather than write, which is the sharpest scope trap in the API.

Do I need a paid Rollbar plan?

Not to connect. Rollbar's pricing page lists a free plan at $0 with 5,000 occurrences and 1,000 sessions per month, and lists REST API access along with the Terraform provider across every tier, so API access is not itself gated. Two node-level gates are documented on Rollbar's API reference pages rather than on the pricing page, which is exactly the sort of claim worth checking against your own account before you build on it: assigning a team on an item update is described there as an Advanced or Enterprise feature, and the snooze fields on an item update are described as paid-plan features. The other thing a plan decides is volume rather than access: Rollbar: Report Occurrence consumes your monthly occurrence allowance, so a workflow that reports repeatedly should send a fingerprint so repeats group into one item.

Why does the item id from a Rollbar URL not work?

Because the number in a Rollbar item URL is the per-project COUNTER, not the system-wide item id that every other endpoint wants. This catches people constantly and Rollbar calls it out itself. Rollbar: Find Item is the bridge: give it a counter, or an occurrence uuid produced by your reporting SDK, and it returns the whole item including the real id, which then feeds Rollbar: Get Item, Rollbar: List Item Occurrences and Rollbar: Update Item. On the canvas you rarely need to think about it, because the item picker on those nodes is sourced from Rollbar: List Items and saves the correct id, describing each option by environment and grouping by status so the right one is findable.

Can an AI agent delete my error data?

Three nodes can, and all three are flagged. Rollbar: Delete Occurrence permanently deletes a single occurrence in Rollbar's own words, and it is asynchronous, so a read immediately afterwards can still return the row, which makes a naive verify step misleading. Rollbar: Delete Project is the one with real blast radius: it is permanent, and it takes the project's access tokens with it, so any application still reporting to that project goes dark. Rollbar: Delete Team removes a team. Nothing else in the connector destroys data. Two more nodes are worth gating even though they are not destructive: Rollbar: Invite to Team sends a real email to a real person, and Rollbar: Report Occurrence consumes plan quota. The comfortable surface for an agent is the 31 read nodes plus Rollbar: Update Item; put the deletes behind a condition or an approval task. It is also worth knowing what this connector cannot do at all: it never reads or creates Rollbar access tokens, because those endpoints return live secret values.

How does pagination work, and what should I know about timestamps?

Rollbar uses page-number pagination starting at 1 on items, occurrences, deploys, environments, team users and invitations, with the page size fixed by the vendor rather than chosen by you, and no total-pages field or link header anywhere. Only the item list returns a total count, so a workflow walking history pages until a short page comes back. The account-wide occurrence list is the exception: it takes an explicit limit and a last-id cursor instead. On timestamps, one mismatch will bite anyone doing arithmetic across two nodes: occurrence timestamps come back in MILLISECONDS on the account-wide occurrence list while every window parameter and item timestamp is in SECONDS. Two defaults are worth the same attention: the occurrence counts report defaults to a minimum level of error and so silently excludes warnings, and both metrics endpoints default their timezone to US Pacific rather than UTC.

48 nodes waiting on the canvas

Put Rollbar to work inside your workspace

Connect once, then use every node in visual automations and AI agent workflows across the Mattering platform.

All product names, logos, and brands are property of their respective owners and are used for identification purposes only. Use of these names, logos, and brands does not imply endorsement or affiliation. Rollbar is a product of its respective owner; Mattering is an independent platform.

Start Free Explore our Products