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.
Connect Rollbar to Mattering
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
Update Deploy returns 403 with a read and write project token
Update Deploy returns 409
Test Connection fails for a credential I know is valid
An item id from a Rollbar URL is not found
A count report is missing warnings, or the days do not line up
An RQL result read comes back empty
A deleted occurrence still comes back from a read
A user search by email returns nothing
Reporting an occurrence fails with 413, or burns through the plan allowance
A workflow starts returning 429
Related
The Rollbar MCP
What connecting Rollbar unlocks for AI agents and automations, with common uses and FAQs.
More guides
All Automations documentation
Every integration guide, plus how connectors, credentials, and workflows fit together.
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.