Menu

Mattering Automations Rollbar integration

Connect Rollbar to Mattering Automations: items, occurrences, deploys, code versions, occurrence and resolution-time metrics, RQL queries, and the account surface of projects, users, teams and invitations as workflow steps, authenticated with Rollbar's scoped access tokens.

The Mattering Automations Rollbar integration puts Rollbar API v1 on your automation canvas: items with list, get, find and update; occurrences with their full payloads and a permanent delete; deploy reporting and tracking; environments and code versions with per-release item statistics; occurrence, activated-item and top-item reports; occurrence, item and resolution-time metrics; asynchronous RQL queries; and the account surface of projects, users, teams and invitations. 48 nodes, 31 that read and 17 that act.

The wire format is a single header, X-Rollbar-Access-Token, against Rollbar's one global host. There is no regional or 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 integration never does, because a token in a URL leaks into logs and proxies.

The scoping is the part that needs a moment. Rollbar issues three kinds of access token and one token does not cover the API, so this credential holds up to three and every node declares which one it needs. An ACCOUNT token reaches projects, users, teams and invitations, and reaches project data when the node's project id is filled. A PROJECT token reaches one 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. Rollbar states that newly created project tokens can no longer combine post_server_item with other scopes, so those really are separate tokens rather than one token with more boxes ticked.

Before you start

  • A Rollbar account with at least one project. 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.
  • The tokens you actually need, which depends on what you are automating. 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, reporting a deploy, or UPDATING a deploy needs a POST token with the post_server_item scope.
  • Two node-level gates documented on Rollbar's API reference pages rather than on its pricing page, so confirm them against your own 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.
  • An awareness that reporting occurrences consumes plan quota. Rollbar: Report Occurrence counts against your monthly occurrence allowance, so send a fingerprint when the same automation can fail repeatedly and the repeats will group into one item.
  • A Mattering workspace with access to the Automations app.
  • Not stored here and not reachable from here: Rollbar access token management. Those endpoints return live token values and mint or revoke credentials, so this integration deliberately ships no node that reads or creates a Rollbar token.

Create your Rollbar access tokens

Create only the tokens your workflows need, in the two places Rollbar keeps them. Account tokens live at the account level; project tokens and post tokens live inside a project. The one thing to plan for is that the post scope cannot be combined with read or write on a new token, so reporting deploys and reading items are two separate tokens rather than one.

For the account surface: open Rollbar, go to Account Settings then Account Access Tokens, create a token with read and write, and copy it. This is what Rollbar: List Projects, the user nodes, the team nodes, the invitation nodes and Rollbar: Get Resolution Time Metrics need.
For one project's data: open that project, go to Settings then Project Access Tokens, create a token with the read scope, adding write if you want to resolve, mute or assign items, and copy it. This is what the items, occurrences, deploys, environments, versions, reports, metrics and RQL nodes need.
For reporting: in the same Project Access Tokens screen, create a second token with the post_server_item scope and copy it.
This has to be a SEPARATE token. Rollbar's access tokens page states that for newly created project tokens, post_server_item and post_client_item can no longer be combined with other scopes, so the token that reads your items cannot report a deploy and the token that reports deploys cannot read anything.
The sharpest trap in this API: UPDATING a deploy requires the post token, not a read and write project token. Rollbar's own update-a-deploy page says so. A perfectly good project token will get 403 on that one node forever with no hint why, so create the post token even if reporting is not your main use.

Connect Rollbar to Mattering

In Mattering Automations, open Connectors and click Add Connector.
Choose Rollbar from the list.
Click Create new credential and paste each token into its own field: Account Access Token, Project Access Token, and Post Token (post_server_item). Leave the fields you do not need blank.
All three fields are individually optional and at least one is required. Fill only what your workflows use; nodes that need a token you did not store fail with a message naming which token and where to create it, rather than with a bare provider error.
Tokens are stored encrypted in Google Secret Manager and never appear in workflow logs.
Click Test Connection. Mattering tries the account token against Rollbar's project list and the project token against its item list, then reports which of them verified. That is deliberate: no single read proves this credential, because there is no single credential.
A post-only credential correctly FAILS the test, with a message saying a post token cannot read anything. That is true rather than a defect, and it is better learned at credential time than inside a workflow.
Click Connect. All 48 Rollbar nodes appear in your canvas palette.

Verify it works

Open any automation canvas and check the palette: a Rollbar section should list the read and action nodes. Which node you verify with depends on which token you stored, and that is the point of this section.

With a PROJECT token: drop Rollbar: List Items onto the canvas and run a test step. It is the natural probe for a project credential and the source of the item picker used on four other nodes, which describes each option by environment, groups by status, and supports Rollbar's own free-text search over item titles. Note the shape while you are here: rows sit under a result region rather than at the top level, and this is the only lister in the API that returns a total count.

With an ACCOUNT token: drop Rollbar: List Projects onto the canvas instead and run it. That proves the account half, and its output feeds the project picker used on 27 fields across the connector.

With an account token but no project token, add one more step, because this is where a 403 usually comes from. Drop Rollbar: List Items onto the canvas and fill its Project ID field from the picker before running it. An account token reaches project data only when a project id travels with the request, and the connector refuses locally when that field is empty rather than sending a request that is certain to fail.

Everything in this verify path is read-only, so it cannot reach the three destructive nodes, cannot send an invitation email, and cannot consume occurrence quota. It is safe to re-run whenever you rotate a token.

Node reference

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

Read and query nodes 31

Rollbar: Find Item

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

rollbar_get_activated_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

rollbar_get_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

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

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

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

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

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

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

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

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

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

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

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

rollbar_get_team

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

Rollbar: Get Top Active Items

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

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

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

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

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

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

rollbar_list_version_items

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

rollbar_create_rql_job

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

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

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.

Using the integration

On the automation canvas

Rollbar nodes chain with every other node, which is where the value is over reading Rollbar in a browser. A schedule can poll Rollbar: List Items, open a Mattering task with the stack trace attached, post to a channel, and write a weekly count into a database in one run. A release webhook can call Rollbar: Report Deploy and then check the release with Rollbar: Get Code Version once real traffic has hit it. Two values do most of the wiring: the project id, which is a picker sourced from Rollbar: List Projects on 27 fields, and the item id, which is a picker sourced from Rollbar: List Items and saves the correct id rather than the counter you see in a URL. The environment field is a dependent picker: choose a project and the environment list narrows to that project's own.

From AI assistants over MCP, and how this differs from Rollbar's own MCP server

Every node speaks MCP, the open protocol for connecting AI assistants to tools, so Claude, ChatGPT, and Matter, the assistant built into the platform, can drive the same surface. Rollbar publishes an MCP server of its own and it is worth knowing before you choose. It is a stdio server, so your AI tool runs it directly rather than you running a process or connecting over HTTP, and it carries 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. For a coding assistant that should be able to look up the error it just caused, that is the right tool and this guide will not pretend otherwise. This integration is the operations side of the same access: 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, adding RQL, the reports and metrics families, environments, deploy reporting and updating, and the whole project, team and invitation administration surface; the tokens live once in a shared workspace store rather than in each developer's local configuration; and the three destructive nodes are flagged so they can be gated. One thing Rollbar's server has that this does not: session replay, deliberately not shipped here because replays are recordings of real end users and the replay id has no lister behind it.

Which token each node family needs

Every node states this in its own description, and the connector picks per node rather than sending whatever is stored, but it helps to hold the map. ACCOUNT token: projects, users, teams, invitations and Rollbar: Get Resolution Time Metrics, which spans projects. PROJECT token: items, occurrences (including Rollbar: Delete Occurrence), the reports and metrics family, deploy READS, environments, code versions and every RQL node. POST token: Rollbar: Report Occurrence, Rollbar: Report Deploy and, unexpectedly, Rollbar: Update Deploy. Two behaviours follow from the map. On a project-scoped node the connector will use the account token when no project token is stored, but it refuses LOCALLY if the node's Project ID is empty, because an account token is scoped by that parameter and the request would otherwise 403. On an account-scoped node there is deliberately no fallback to the project token, because that request would 403 and the 403 would read as a bad credential rather than as the wrong KIND of credential, which is the confusion this design exists to prevent.

Items, and the counter that is not an id

The number in a Rollbar item URL is the per-project COUNTER, not the system-wide item id that every other endpoint wants, and Rollbar calls this 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 have to think about it, because the item picker saves the correct id. Rollbar: Update Item is the node that closes a triage loop: resolve, mute, assign or change the level so Rollbar agrees with wherever your team actually works. Two of its fields are gated by plan according to Rollbar's own reference pages: assigning a TEAM is described as Advanced or Enterprise, and the snooze fields as paid-plan features.

Deploys and code versions

Rollbar: Report Deploy records a release and Rollbar: Update Deploy moves it to succeeded or failed afterwards. Three things about that pair are documented and will each cost you an afternoon otherwise. The update needs the POST token rather than a write token. The update is a one-way transition and answers HTTP 409 unless the deploy is currently in the started state. And reporting a deploy answers with a different envelope from the rest of the API, carrying just a deploy id, which is what the node's sample output shows. On the reading side, Rollbar: List Deploys and Rollbar: Get Deploy show what shipped, while the release-health pair is Rollbar: Get Code Version and Rollbar: List Items in Code Version: the first splits a version's items into new, repeated, reactivated and resolved by severity, and the second lists them, with the event type required so you say which of the four you want. Rollbar documents no lister for code versions, so that field is free text: the value comes from your own deploy revision.

RQL: asynchronous by design

Rollbar: Run RQL Query submits a query and returns a job id rather than rows, and it needs only the read scope despite being a POST. From there, Rollbar: Get RQL Job polls the status, Rollbar: Get RQL Job Result reads the rows once it has finished, Rollbar: List RQL Jobs shows what is running and Rollbar: Cancel RQL Job stops one. Build it as start, poll, then read. Chaining the result read directly onto the submission will usually find nothing there yet, which looks like an empty answer rather than a timing problem. This is the surface that lets an agent answer a question nobody built a report for, which is most of the questions people actually ask.

Reports and metrics, and the two defaults that change your numbers

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 with your own aggregates and bucket width. Rollbar: Get Resolution Time Metrics spans projects and needs the account token. Two defaults will quietly change a chart, so both are on the nodes: the occurrence counts report defaults its minimum level to 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. Two response shapes are worth knowing before writing a path expression: the two count reports return positional two-element pairs of timestamp and value with no column names at all, and Rollbar: Get Top Active Items returns bare hourly integers with no timestamps, positioned against an implicit last 24 hours. On aggregation, the metrics nodes deliberately declare no rule for their values, because what a value MEANS depends on the aggregate you asked for: a distinct count is not additive across days, and a median of medians is not a median, so re-request the window you want rather than recombining smaller ones.

Reporting occurrences from a workflow

Rollbar: Report Occurrence sends an item to Rollbar from the canvas itself, which is how a batch job, a webhook handler you built here, or a failing automation step lands in the same place as the rest of your errors instead of in a log nobody reads. It needs the POST token. Two limits: Rollbar caps the payload at 1024 KB and answers HTTP 413 above it, and every reported occurrence consumes your plan's monthly allowance, which Rollbar lists at 5,000 occurrences on the free plan. Send a fingerprint when the same automation can fail repeatedly so the repeats group into one item rather than burning the allowance. The occurrence nodes also carry the API's one unit mismatch: occurrence timestamps come back in MILLISECONDS on the account-wide occurrence list, while every window parameter and item timestamp is in SECONDS.

Projects, teams and invitations

The account half is what an organization running many Rollbar projects wants 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, noting that the user list filters by email as an EXACT match rather than a search, so a partial address returns nothing rather than a shortlist. 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 your source of truth, and Rollbar: Invite to Team, Rollbar: Get Invitation and Rollbar: Cancel Invitation cover onboarding. Two things to expect: inviting someone SENDS a real email, and the invitation list returns every invitation ever sent, including accepted, rejected and cancelled ones, so filter before you act on it. Rollbar's own documentation disagrees with itself about which token the assign and remove team-to-project pair needs; this integration sends the ACCOUNT token for both, and the remove node's description says so, which tells you what to retry with if you hit a 403.

Pagination and response shapes

Rollbar wraps its successful responses in an error-code and result pair, so rows live inside the result region rather than at the top level, and the exact path varies by endpoint: some return a named collection and several return a bare array. The node sample outputs are the reliable guide. Pagination is page-number based starting at 1 on items, occurrences, deploys, environments, team users and invitations, with the page size fixed by Rollbar rather than chosen by you, and there is no link header and no total-pages field, so a workflow walking history pages until a short page comes back. Only the item list returns a total count. The account-wide occurrence list is the exception to all of that: it takes an explicit limit and a last-id cursor. Two response oddities worth carrying: reporting a deploy answers with just a deploy id and no error-and-result envelope at all, and cancelling an invitation answers with a plain description string.

Troubleshooting

A node returns 403 and the token looks correct
On Rollbar, 403 is ambiguous by design: it is what you get for a missing token, an invalid token AND a mis-scoped one, and there is no 401 to distinguish them. Read it against the node. If the node needs an ACCOUNT token and you stored only a project one, that is the wrong KIND of credential; create an account token under Account Settings then Account Access Tokens. If the node needs a PROJECT token and you are relying on the account token, fill the node's Project ID field, because an account token reaches project data only when a project id travels with the request. If it is a WRITE that fails while reads work, the project token is probably read-only; add the write scope or mint a new token. And if it is Rollbar: Update Deploy, see the next entry, because that one is not what anybody expects.
Update Deploy returns 403 with a read and write project token
This is the sharpest scope trap in the API and it is Rollbar's rule, not ours. Updating a deploy requires the post_server_item scope rather than write, which Rollbar states on its own update-a-deploy page, so a perfectly good read and write project token will 403 on that node forever. Create a POST token under Project then Settings then Project Access Tokens with the post_server_item scope, and paste it into the credential's Post Token (post_server_item) field. It has to be a separate token: Rollbar no longer lets newly created project tokens combine post_server_item with other scopes.
Update Deploy returns 409
Not a permission problem this time. Rollbar allows the update only while the deploy's current status is started, and the transition is one-way per deploy, so a deploy already marked succeeded or failed cannot be updated again. Check the current status with Rollbar: Get Deploy before updating, and design the pipeline so Rollbar: Report Deploy records the release in the started state and exactly one later step moves it. If your release pipeline can report the same deploy twice, guard against the second update rather than retrying it.
Test Connection fails for a credential I know is valid
First check what you actually stored. A POST-only credential correctly fails the test, because a post token cannot read anything at all, and the message says so; that is the truth about the token rather than a fault. If you stored an account token, the test tries it against Rollbar's project list; if you stored a project token, it tries the item list; and it reports which of them verified, so a partial pass is informative rather than a failure. Then check for whitespace picked up in the copy, and confirm the token still exists in Rollbar. One thing that proves nothing and is worth avoiding: Rollbar's status ping endpoint is UNAUTHENTICATED and returns success for any garbage, so anything that tests a connection with it is testing nothing.
An item id from a Rollbar URL is not found
The number in a Rollbar item URL is the per-project COUNTER rather than the system-wide item id, and Rollbar documents the distinction itself. Use Rollbar: Find Item with that counter, or with the occurrence uuid your reporting SDK produced, and it returns the whole item including the real id. Feed that id into Rollbar: Get Item, Rollbar: List Item Occurrences or Rollbar: Update Item. On the canvas the simpler answer is the picker: the item field on those nodes is sourced from Rollbar: List Items and saves the correct id, describing each option by environment and grouping by status.
A count report is missing warnings, or the days do not line up
Two defaults rather than two bugs. Rollbar: Get Occurrence Counts defaults its minimum level to error, which silently EXCLUDES warnings, so a chart that looks quiet may simply be filtered; lower the level to include them. And both Rollbar: Get Occurrence Metrics and Rollbar: Get Resolution Time Metrics default their timezone to US Pacific rather than UTC, so day boundaries shift by several hours against anything UTC-based. Set the timezone explicitly when you are comparing Rollbar to another source. One shape note while you are in there: the two count reports return positional pairs of timestamp and value with no column names at all, and Rollbar: Get Top Active Items returns bare hourly integers positioned against an implicit last 24 hours, so read them by position rather than by key.
An RQL result read comes back empty
Almost always timing. RQL is asynchronous: Rollbar: Run RQL Query returns a job id rather than rows, so chaining Rollbar: Get RQL Job Result straight onto it usually finds nothing there yet, which looks like an empty answer rather than a job still running. Put Rollbar: Get RQL Job in between and poll it until the job reports finished, then read the result. If the job never finishes, Rollbar: List RQL Jobs shows what is in flight and Rollbar: Cancel RQL Job stops it.
A deleted occurrence still comes back from a read
Expected. Rollbar's own wording is that deleting an occurrence permanently removes it from the UI and the API, and the deletion is ASYNCHRONOUS, so a read immediately afterwards can still return the row. Do not build a verify-immediately-after step on it, because it will report a false failure. This is also a good moment to remember what deletion means here: Rollbar: Delete Occurrence has no undo, Rollbar: Delete Project is permanent and takes the project's access tokens with it so anything still reporting to that project goes dark, and Rollbar: Delete Team removes a team. All three are flagged so they can be gated behind a condition or an approval task.
A user search by email returns nothing
Rollbar's user list filters by email as an EXACT match rather than as a search, so a partial address or a different case returns an empty list rather than a shortlist, and there is no free-text search on that endpoint to fall back on. Pass the full address. This is also why the user field on other nodes is a picker sourced from Rollbar: List Users with the email shown as the description, rather than a search box: two people can share a display name and the address is what tells them apart.
Reporting an occurrence fails with 413, or burns through the plan allowance
Two separate limits on the same node. Rollbar caps the payload for a reported item at 1024 KB and answers HTTP 413 above it, so trim the payload rather than retrying: a large context object or an embedded response body is usually the cause. On volume, every occurrence Rollbar: Report Occurrence sends counts against your plan's monthly allowance, which Rollbar's pricing page lists at 5,000 occurrences on the free plan. Send a fingerprint so repeated failures of the same automation group into one item, and gate the node so a retry loop cannot report the same error hundreds of times.
A workflow starts returning 429
Rollbar rate limits per token and answers HTTP 429 when the limit is exceeded. Project access tokens carry a configurable window, visible on the token in Rollbar's own UI, so the first place to look is the token's own setting rather than the workflow. After that, look for the shapes that generate volume without anyone noticing: a loop calling Rollbar: Get Item per row instead of reading the list once, a scheduled metrics refresh running more often than the data changes, and configuration panels with several pickers open. Option pickers are served from a short-lived cache, which helps, but a per-item loop is not.

Rollbar 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