MCP server
Let your AI assistant look up your apps, issues and reports in Reporting API App over the MCP, and triage issues for you.
The MCP server shows an assistant the organizations, apps, issues and reports you can see in the web app, and never more. With write access, it can also set an issue's state, assignee and notes, as the issue page does. Your client signs you in with OAuth 2.1; there is no API key to create or rotate.
Endpoint
https://www.reporting-api.app/mcp
Clients discover everything else from the endpoint. An unauthenticated request answers 401 with a
WWW-Authenticate header that points at the protected resource metadata:
| Document | URL |
|---|---|
| Protected resource metadata (RFC 9728) |
https://www.reporting-api.app/.well-known/oauth-protected-resource/mcp
|
| Authorization server metadata (RFC 8414) |
https://www.reporting-api.app/.well-known/oauth-authorization-server
|
Authorization
- OAuth 2.1, authorization code only — Your client opens a browser, you sign in to Reporting API App and approve the connection on a consent page
-
Dynamic client registration (RFC 7591) — Clients register themselves at
/oauth/register. Every client is public: registration never issues a client secret -
PKCE with S256 — Required for every
client.
plainand missing challenges are refused -
Redirect URIs —
https, or loopbackhttp(127.0.0.1,[::1],localhost, any port), matched exactly -
Scopes —
reports:readandreports:write; see Read and write scopes -
Audience — Tokens are bound to the MCP endpoint (RFC 8707
resource) and work nowhere else. Send them only in theAuthorization: Bearerheader
Choose organizations at consent
The consent page lists your organizations. Pick the ones the assistant may use; it sees no other. To share more later, connect again and pick them; the ones you already shared stay ticked. Access follows your membership on every call: when someone removes you from an organization, your connections end.
Read and write scopes
The consent page lists what the assistant asks for, each new permission ticked. Untick any you don't want to give. Permissions the assistant already holds are listed as already granted.
| Scope | On the consent page | Lets the assistant |
|---|---|---|
reports:read |
View reports | See your apps, issues and reports: every tool below except update_issue, and every prompt |
reports:write |
Change issues | Change your issues' state, assignee and notes: update_issue |
- Connect read-only — When you first connect, untick “Change issues” on the consent page. A read-only assistant doesn't see the tools that change data at all. An assistant that already holds write access keeps it until you revoke it
-
Add write access later — When a read-only assistant calls a write tool, the server answers
403withinsufficient_scopeandscope="reports:write", and your client may ask you to consent again. The consent page shows read access as already granted and asks only for write access, so the assistant keeps everything it could do before. If your client says the scope is invalid, remove the server from your client and add it again. A client set up for reading only can't widen its own access - See what each client holds — Your MCP page in the app lists every connected client with its permissions, under the same names as the consent page. Revoke a client there to end its access. A new consent only adds to what a client holds, so to take a permission or an organization back, revoke the client and connect again
- Your role still applies — Write access never lets the assistant do more than you can in the web app
Tools
Ids are the same short ids the web app shows in its URLs. A record
you can't see, or that doesn't exist, answers Not found.
| Tool | Arguments | Returns |
|---|---|---|
list_organizations |
none |
The organizations you shared with this connection, each with mcp_access, and a hint when you have
more. An organization without MCP access also shows its plan and an upgrade_url where an owner
upgrades
|
list_apps |
organization_id |
Each app's id, name, environment, report count and time of the last report |
get_app |
organization_id, app_id |
One app's reporting endpoint, allowed origins and report count. Needs a role on the app, as its page in the web app does |
list_issues |
organization_id; optional app_id, type, disposition,
state, assignee, start_date, end_date,
first_seen_after, seen_in_release, new_in_release,
include_filtered, sort, page
|
Issues (reports grouped by cause), most recently seen first unless sort is
first_seen_at. Without app_id, across every app you can see. Each row names its app
and the response carries total_count, the number of matches across all pages.
first_seen_after keeps issues first seen at or after that bound. Every date takes a day
(YYYY-MM-DD, a whole day in the app's time zone) or a date-time with Z or an offset
(2026-11-14T16:30:00Z, that exact instant). reports_count is the all-time total;
with start_date or end_date, window_reports_count counts the reports
still stored that fall in that window (it can be 0 for an issue active in the window). Every date filter
matches when the error happened: the report's arrival minus its age, as the browser reports it. CSP,
permissions-policy and document-policy issues carry disposition: enforce (the
browser blocked it) or report (report-only policy); disposition filters on it. Every
issue carries its state (open, in_progress, resolved or
ignored), when that last changed, and its assignee. state filters on
it, and unresolved keeps open and in-progress issues; assignee takes
me, none or a member's email address. Each issue names the releases it was first and
last seen in. seen_in_release keeps issues with a stored report from that release and
new_in_release issues first seen in it. A report from a newer release into a resolved issue opens
a new issue: regression_of names the resolved one, which names the new one in
regressed_as and takes no new reports. Issues made only of known noise, such as browser extension
violations, are left out unless include_filtered is true; filtered_reports_count
counts an issue's reports filtered as noise
|
get_issue |
organization_id, issue_id; optional start_date, end_date
|
An issue's summary, state and assignee, its Markdown notes with who edited them last and when, first and last
seen times, the browsers, systems and pages affected, a sample report and a link to the docs for its fixes.
With start_date or end_date, the browsers, systems and pages cover only reports in
that window, and window_reports_count and window give its total and bounds.
Network-error issues add the status codes, server IPs and elapsed
times (in buckets: under 100 ms, up to 1 s, up to 10 s, 10 s or more) of their reports.
daily_counts lists the issue's reports per day in the app's time zone
(Europe/Berlin, the same days as YYYY-MM-DD dates), with 0 for quiet days, so a
regression or a fix shows at a glance. It covers the window (at most its last 90 days), or without a
start_date the last 14 days up to end_date or today, counting every report of the
issue. filtered_by lists the noise rules that filtered its reports, with each rule's name, docs
link and count. A regression carries the resolved issue it came from, with its notes. A resolved issue
carries reports_since_resolved, its reports since the resolve per release, so you can see a fix
that didn't hold
|
update_issue |
organization_id, issue_id; one or more of state,
assignee, notes
|
Sets an issue's state or assignee (me, none or a member's
email address) or notes (Markdown, up to 10,000
characters; replaces the current notes, an empty string clears them; report:<id> links a
report), and answers the issue's id, state, when it changed, its assignee and when its notes changed. Needs
reports:write and a role that lets you see the issue. Every change is kept in the issue's history
with your name, and a value that is already set changes nothing. After a resolve, a report from a release
first seen after the issue's last seen release opens a new linked issue; a report from that release or an
older one changes nothing; a report without a release, or into a network error issue, reopens the issue when
it happened after the resolve. Resolving answers the issue's last seen release, with a warning when that is
the app's newest release. Ignored issues send no notifications
|
list_releases |
organization_id, app_id; optional page
|
The releases an app's reports named in the reporting endpoint's release parameter, newest first,
with when they were first and last seen, their report count, how many of their reports were filtered as noise,
the issues first seen in them and a link from the app's release URL template. Releases order by when we first
saw them, not by name. A network error report's release can lag one deploy, because the browser caches the
endpoint
|
list_reports |
organization_id; optional app_id, issue_id, type, dates,
browser, platform, os, mobile, bot,
release, trace_id, request_id (exact match),
include_filtered, status_code, phase, protocol,
error_type, server_ip, min_elapsed_time,
max_elapsed_time, page
|
Reports, newest first, with the filters of the web app, and total_count, the number of matches
across all pages. Ordered and date-filtered by occurred_at, when the error happened, as for
issues. Each row also has received_at (when we stored the report) and age_ms (the
age the browser reported); occurred times can be off by up to 24 hours because the browser supplies the age.
get_report's body timestamp already has the age subtracted, so do not subtract
age_ms again. Dates take a day or a date-time, as for issues. Network error rows also have a
network_error object with the error type, status code, phase, protocol, elapsed time and server
IP. The network error filters narrow the list to network error reports: status_code (100 to
599), phase (dns, connection or application),
protocol, error_type, server_ip, and min_elapsed_time and
max_elapsed_time in milliseconds (0 to 86,400,000). Reports filtered as known noise, such as
browser extension violations, are left out unless include_filtered is true or you pass an
issue_id; each row's noise_rule gives the key, name and docs link of the rule that
filtered it, or is null (see Noise Rules).
exclude_extensions is deprecated: false means include_filtered true
|
count_reports |
organization_id; optional group_by (up to three of day,
hour, report_type, issue, host, status_code,
phase, release), limit and every list_reports filter
except page
|
Report counts in one call, to tell whether a problem is new and whether it is growing, for example network
errors per day and status code. Day buckets are days in the app's time zone (Europe/Berlin, the
same days as YYYY-MM-DD dates) and start at the day's first instant with its offset; hour buckets
are UTC. Both follow occurred_at, when the browser generated the report (for reports sent to a
report-uri endpoint, which carry no age, when it arrived). Groups come newest bucket first,
otherwise largest first; at most limit groups (default 100, up to 500), truncated
says when more exist and total_count counts every matching report. Grouping by
status_code or phase counts only network error reports. Reports filtered as known
noise are left out unless include_filtered is true or you pass an issue_id
|
get_report |
organization_id, report_id |
One report's metadata, user agent and full body, with the noise_rule that filtered it, as in
list_reports
|
get_documentation |
optional path |
A page of this documentation as Markdown. path takes a docs_url, its
.md address or a path such as docs/getting-started. Without path, the
index of pages, the same as /llms.txt. Needs no organization
|
submit_feedback |
kind, body; optional tool_name, organization_id,
issue_id
|
Sends a note to the Reporting API App team, for example how you resolved an issue. Works on every plan |
Lists return 25 records per page; ask for the next_page the answer names. Issues and reports carry a
docs_url with the causes and fixes of their report type; get_documentation returns that page
as Markdown.
Reports (list_reports, get_report and the sample_report of
get_issue) include release, trace_id, span_id and
request_id when the reporting endpoint URL carried
them. See Add release and trace context. Anyone
with the endpoint URL can send these values, so release and request_id come back fenced as
untrusted text.
Names, URLs, origins and report contents come back fenced as untrusted text, so the model treats them as data, not instructions.
Resources
Clients that support MCP resources can also read an issue or a report by its address, which every issue and report
answer includes as uri:
reporting-api://organizations/{organization_id}/issues/{issue_id}
reporting-api://organizations/{organization_id}/reports/{report_id}
Prompts
Clients that support MCP prompts offer these jobs as slash commands. Each one tells the assistant which tools to call, in order; the tools check what you may see on every call. They need only read access: when a prompt suggests changing an issue, an assistant without write access lists the changes for you to make instead.
| Prompt | Arguments | Does |
|---|---|---|
triage_new_issues |
app, optional since (YYYY-MM-DD, default the last 7 days) and type
|
Reads the app's unresolved issues first seen since that day and their documentation, sorts them into bugs, noise and ones you decide, and proposes a state, assignee and note for each |
verify_fix |
issue (its id or its link), optional release
|
Counts the issue's reports per release and tells whether the fix held, isn't deployed yet, or didn't work |
explain_report_type |
report_type, optional app |
Explains what triggers a report type and how to fix it, with the app's own issues as examples |
Example questions
- Which CSP issues appeared in my shop app this week?
- How do I fix issue “Refused to load the script”?
- Show the newest report of my checkout app and tell me which page caused it.
- Mark the injected-script issues in my shop app as ignored, and assign the rest to me.
Fix and verify with your agent
The tools cover a whole fix, from the first report to the release that stopped reporting it. A coding agent with access to your code runs these steps in one conversation:
-
Triage. “Which issues are new in my shop app since yesterday?” The agent calls
list_issueswithfirst_seen_after, ornew_in_releasefor the latest deploy. -
Diagnose. “What causes the newest CSP issue?” It reads the issue and its sample report
with
get_issueandget_report, then our guide for that report type withget_documentation, and narrows the cause withcount_reportsgrouped by host, status code or release. -
Fix and record. It changes your code, then calls
update_issueto set the state to in progress, assign you and write notes on the cause and the fix. This needs write access (reports:write). -
Verify. After you deploy with a release on your reporting endpoint
(add release context), “Did the new
release fix it?” The agent checks
count_reportsfor the issue, grouped by release, and resolves it. A report from a newer release into the resolved issue opens a regression issue; network-error issues reopen instead. Give the new release enough traffic before you resolve: no reports can also mean nobody reached that code yet.
Map a minified bundle to your source
Reports point at the code the browser ran: CSP, Permissions Policy, Document Policy, deprecation and intervention
reports can carry sourceFile, lineNumber and columnNumber, the script in your
production bundle, or the page itself for inline code. Reporting API App takes no source map upload. Your agent works
in your repository, so it maps that position with your own source maps: it builds or finds the map for the release the
report names, looks up the original file and line, and fixes the code there.
To tell your code from a vendor's, the agent compares the host of sourceFile with the app's allowed
origins from get_app and with the hosts your build deploys assets to, such as your
CDN. A chrome-extension:// or other extension
URL is a browser extension. For a script from any other host, the
fix is a version upgrade, a vendor ticket or a policy change rather than an edit to your code.
Connect a client
Claude Code
claude mcp add --transport http reporting-api https://www.reporting-api.app/mcp
Codex and ChatGPT
[mcp_servers.reporting-api] url = "https://www.reporting-api.app/mcp"
In ChatGPT, add the endpoint URL as a custom connector with OAuth. It registers itself; you only sign in and pick your organizations.
Other clients
Any client that supports remote MCP servers over Streamable HTTP with OAuth works the same way: add the endpoint above, and the client registers itself and opens the sign-in page.
Revoke a connection
The MCP server page in your profile lists each connected client with the host it redirects to, the organizations you shared, when you connected it and when it last fetched a token. Revoke one there and its tokens stop working at once; the client must ask for your consent again.
Reporting API App also ends every connection of yours when:
- you change or reset your password
- you delete your account
- someone removes you from an organization
Limits
-
Plans — The MCP server is part of the Pro and Enterprise plans, and you can try it during the
free trial. For an organization on Starter, every tool except
list_organizations,get_documentationandsubmit_feedbackanswers with its plan and a link to upgrade, which only an owner of the organization can follow. After a downgrade, the next call is refused; your apps, issues and reports stay as they are -
Your data stays as it is — No tool changes your organizations, apps or reports.
update_issuechanges only an issue's state, assignee and notes, and records each change.submit_feedbacksends a note to the Reporting API App team - Access tokens live 1 hour. Clients refresh them on their own
- Refresh tokens rotate on every use. They expire after 90 days unused, and 365 days after consent at the latest; then you connect again
- Refresh token reuse — Presenting a rotated refresh token again revokes the connection, since it signals a stolen token
- Registration — 20 client registrations per IP address per hour
Next steps
- Getting Started — Create an app and start receiving reports
- Integrations — Route reports to AppSignal, webhooks and Google Chat
- Triage Issues — Issue states, assignees, history and notes, as the web app shows them