API

Lists all projects, with their DSNs. Each project also has:

• repository: owner/name, or null
• trust: the trust level now, low or high
• trust_setting: low, high, or null (automatic)
• source_trust: always the same as trust
• source: where the events of the last 30 days came from: server, browser (a browser, a mobile app or an unknown SDK), mixed, or null (no events in 30 days)
• server_seen_at and client_seen_at: the last event from a server source, and from a browser, mobile or unknown source (written at most once an hour), or null
• allowed_origins: a list of origins, or null (any origin)
• daily_quota: the daily event quota, or null (no quota)
• scrub_keys and scrub_patterns: the scrub settings of the project
• events_24h and last_event_at: the events of the last 24 hours, and the time of the last event
• demo: true for a demo project
• events_today: the events of the project since 00:00 UTC (a repeated event_id counts once)

Creates a project and its DSN.

Body: {"name": "My App", "platform": "node"}. name has 1 to 100 characters. platform is optional (32 characters or fewer).

Returns 201:

The project CLI calls these two endpoints.

Changes the settings of a project. Needs the admin scope. :project is the public project ID or the slug. The body has one or more of these fields:

Other fields or values give 400. An unknown project gives 404. Returns the project, as in GET /v1/projects. The activity row project.update has the changed fields.

Deletes a project. Needs the admin scope. Returns 204, or 404 for an unknown project.

• The DSN keys of the project stop working within 60 seconds.
• The project is hidden everywhere at once, and its name can be used again.
• Pending alerts for its issues are not sent.
• The cron deletes its issues, events, counts, releases, deploys, source maps (with their blobs) and webhooks, in chunks.
• The activity timeline stays.
• Its fixes are not verified any more.
• The agent tokens bound to the project (made with a setup key for it) are revoked, each with a token.revoke activity row.

When REQUIRE_APPROVAL includes delete_project, an API token gets 202 {"status": "approval_required", ...}, and another actor must complete the delete (see Approvals). There is no MCP tool to delete a project.

Adds a DSN key to a project, so that you can rotate the DSN. Needs the admin scope. Returns 201 with public_key and the new dsn.

Revokes a DSN key. Needs the admin scope. Events with the key get 401 within 60 seconds, on every server. Returns 204. The only active key of a project cannot be revoked (409 {"error": "last_key"}): add a new key first.

Lists issues. By default, the issue with the most recent event comes first.

When project matches no project ID and no slug, the response is 404 {"error": "project_not_found"}.

next_cursor is null on the last page. ingest is the ingest state (see Settings and health).

Each issue has these fields: id, project_id (the public project ID), title, culprit, type, level, platform, status, times_seen, stored_events, events_24h, events_7d, users_affected, priority, first_seen, last_seen, first_release, last_release, fingerprint, fingerprint_version, merged_into, claim and trust.

• events_24h and events_7d: the events in the last 24 hours and the last 7 days. Checkend counts them per UTC hour, so each window is the full hours inside it.
• users_affected: the number of different users. The user of an event is its user.id, else user.email, else user.username, else user.ip_address. For this count, Checkend stores only a hash of the value. The count stops at 1,000 per issue. An event without a user adds no user.
• priority: the priority score.
• merged_into: the ID of the issue that this issue was merged into, or null.
• trust: the trust level of the project, low or high.
• source_trust (always the same as trust) and source (server, browser, mixed or null): see the project fields above.

An SDK that sends the same event again (the same event_id, while the event is stored) does not make the counts go up twice. A merge moves the hourly counts and the users to the target issue.

claim is {"holder": "agent-a", "expires_at": "..."} when the issue has an active claim, or null.

times_seen counts all events. stored_events counts the events that Checkend stored (see the caps).

Returns one issue, with two more fields:

• latest_event_id: the ID of its most recent stored event.
• test: true for the test issue of a setup (see Set up with an agent).
• fix: the linked fix (see Verify fixes), or null. It has kind, commit or pr_url, linked_by, linked_at, release, environment, deployed_at, outcome (null, verified or regressed), verified_at, regressed_at and regressed_in.

Lists the stored events of an issue, the most recent first. limit is 1 to 100 (the default is 25).

Each event has these fields: id, issue_id, project_id, event_id, timestamp, received_at, level, release and environment.

Sets the status to resolved. No body. Returns 200 with {"data": <issue>}, or 404 when the issue is unknown or merged.

When a new event arrives for a resolved issue, the issue becomes unresolved again (a regression). The activity timeline then gets issue.regress. An ignored issue stays ignored.

Sets the status to ignored. No body. Returns 200 with {"data": <issue>}, or 404.

Sets the status to unresolved. No body. Returns 200 with {"data": <issue>}, or 404.

Merges other issues into this issue (the target). Body: {"source_ids": [12, 15]}, with 1 to 10 issue IDs. Returns 200 with {"data": <target issue>}.

What a merge does:

• The events and the counts (times_seen, first_seen, last_seen, stored events) move to the target issue.
• Each source issue gets the status merged, and merged_into is the target ID.
• Later events that would go to a source issue go to the target issue.

The response is 400 with {"error": "invalid_request", "details": [{"path": "source_ids", ...}]} when a source is the target, when the target or a source is already merged, when a source is in another project, or when a source is unknown. An unknown target issue (:id) gives 404.

Links a fix to the issue (see Verify fixes). Body: {"commit": "<SHA>"} or {"pr_url": "https://github.com/<owner>/<repo>/pull/<number>"}, exactly one of them. The SHA has 7 to 40 hex characters (Checkend stores it in lowercase). Returns 200 with the issue: its status is fix_pending, and it has fix.

A new link replaces the open fix. When a deploy with this commit or pull request was already reported, the fix counts as deployed at once. Both fields, another host, or http gives 400. When the project has a repository, a pull request in another repository also gives 400: "The pull request must be in the repository of the project: owner/name." An unknown or merged issue gives 404.

Corrects the AI triage of an issue. Needs issues:write. Body: at least one of category, severity (0 to 3), transient, agent_fixable and noise, and an optional note (at most 500 characters). Returns 201 with {"data": {"recorded": true}}, or 404. The correction is a triage label triage_corrected.

The opposite of a merge: moves some stored events of this issue to a new issue. Body: {"event_ids": [101, 104]}, with 1 to 100 Checkend event IDs (the id from GET /v1/issues/:id/events). Returns 201 with {"data": <the new issue>}.

What a split does:

• The chosen events move to a new issue in the same project.
• The new issue gets the title of the first moved event, the moved events, their hourly counts, and their part of times_seen. The original issue loses these, but it keeps a times_seen of at least 1.
• The users affected stay on the original issue.
• New events still go to the original issue: a split does not change grouping. To group later events in a different way, set an SDK fingerprint (see grouping).

The response is 400 with {"error": "invalid_request", "details": [{"path": "event_ids", ...}]} for an empty list, an unknown event, or an event of another issue. An unknown or merged issue gives 404.

Reports a deploy. Needs the releases:write scope. Returns 201.

A fix counts as deployed only when its commit is the deployed commit or is in commits, or when its pull request is in pull_requests.

The response data has id, project_id, release, environment, commit, deployed_at and fixes_deployed (the IDs of the issues whose fix this deploy contains). An unknown project gives 404 {"error": "project_not_found"}.

The GitHub webhook (see Verify fixes). It is not under /v1, and it does not use a bearer token: GitHub signs each request with the GITHUB_WEBHOOK_SECRET (the X-Hub-Signature-256 header). Without the secret, the endpoint answers 404.

Uploads a source map. Needs releases:write. See Source maps.

The body is the source map JSON (Content-Type: application/json), or a prebuilt index (application/x-checkend-sourcemap-index). Other types give 415. The body is at most 30 MB (else 413). A new upload for the same project, release and path replaces the old map.

Returns 201 with id, project_id, release, name, path, size (the bytes of the index), sources (the number of original files in the map), uploaded_at and uploaded_by.

Errors:

• 400 {"error": "invalid_sourcemap", "reason": "..."}: not version 3, a map with sections (not supported), broken mappings, a broken index, or not JSON.
• 400 storage_not_configured: the Worker has no BLOBS bucket.
• 400 invalid_request: a query parameter is missing.
• 404 project_not_found.

Lists the source maps, the most recent first. Needs issues:read. Query: project (required) and release (optional). An unknown project gives 404 project_not_found.

Deletes a source map. Needs releases:write. Returns 200 with {"data": {"id": ..., "deleted": true}}, or 404 for an unknown source map.

Lists the releases, the most recently deployed first. Needs issues:read. Query: project (optional) and limit (1 to 100, the default is 25).

Each release has project_id, version, commit, created_at and deploys (the latest first). Each deploy has id, environment, commit, source and deployed_at.

One release. Needs issues:read. The project query parameter is required. URL-encode the version. The response has the release and its deploys, and also new_issue_ids (the issues first seen in this release), fixes_deployed (each with issue_id, kind, ref and outcome) and regressed_issue_ids. An unknown release gives 404.

Searches for similar issues. Needs issues:read. Body: an issue_id or a text, and limit (1 to 20). When the feature is off, the response is 409 {"error": "similar_off", ...}.

The fixes that have an outcome (verified or regressed), the most recent first. Needs the admin scope. Query: limit (1 to 1000, the default is 100) and since (a duration or an ISO time).

Each row has fix_id, issue_id, kind, ref, linked_by_type, linked_by, linked_at, deployed_at, outcome, verified_at, regressed_at, regressed_in, hours_to_verified (from the link) and hours_to_fix (from the first event of the issue). A fix that was verified and then regressed has the outcome regressed, and it still has verified_at.

Creates a webhook or an alert. Other fields give 400.

See Start an agent from GitHub Actions and Alerts.

Returns 201 with id, name, url, format, events, min_trust, project_id, created_at, created_by, last_delivery_status and secret (whsec_...). The secret is only in this response.

Errors:

• 400 {"error": "encryption_not_configured", "reason": "Set ENCRYPTION_KEYS: ..."}: the Worker has no encryption keys.
• 400 {"error": "email_not_configured"}: an email alert, but the Worker has no email settings.
• 400 invalid_request with the path url (the reason, see the URL rules), to, project, github_token or spike_threshold.

Lists the webhooks and alerts for agents and people who are not admins. Needs issues:read. It does not show secrets, email addresses (only their number), or the query strings of URLs. The MCP tool list_alerts returns the same list.

Lists the webhooks, without their secrets.

Deletes a webhook. Its pending deliveries fail. An unknown webhook gives 404.

Sends a ping event (issue and brief are null). Returns 202 with {"delivery_id": ...}.

Lists the deliveries of a webhook, the most recent first. limit is 1 to 100 (the default is 25). Each delivery has id, event, issue_id, status (pending, delivered or failed), attempts, last_status (the HTTP status), last_error, created_at, next_attempt_at and delivered_at.

Makes a setup key. Needs the admin scope (a setup key cannot make one). The key lasts 1 hour, and Checkend stores only its hash. GET /v1/setup/keys lists the keys, and DELETE /v1/setup/keys/:id revokes one, and also the agent tokens that it made (each with a token.revoke activity row).

Registers an app: {"name": "...", "platform": "..."} (platform is optional). Returns 201 with created, project and dsn, or 200 on a retry with the same name. A setup key can register at most 10 apps (then 429).

Makes an agent token for an app: {"name": "...", "project": ...}. The token has issues:read and issues:write on every project of the install, not only on its own app. It does not expire. It is revoked with its setup key, with its project, or with DELETE /v1/tokens/:id. A setup key can make at most 5 tokens (then 429).

Sends the one test event of the app (with the tag checkend.test=true). Returns 202, or 409 when the app already has its test event. An app that is not one of the apps of the setup key gives 404.

Reports a setup step: {"step": "sdk_installed"}. Returns 204. The agent token that the setup made for this app can also report it. An app that is not one of the apps of the setup key gives 404; with an agent token, another app gives 403.

The progress of each app: connected_at, sdk_installed_at, test_event_at, first_event_at, agent and first_deploy_at (see Follow the progress), and setup_keys_active. A setup key sees only its own apps. It needs a setup key or the admin scope.

Claims the issue. The body is optional: {"minutes": 60}, 1 to 1440 (the default is 120). Returns 200 with {"data": <issue>}, and the issue has "claim": {"holder": "agent-a", "expires_at": "..."}. The holder is the name of the token (or ADMIN_TOKEN).

The claim succeeds when the issue has no claim, when the claim expired, or when the same token renews its own claim. Otherwise the response is 409: {"error": "claimed", "claim": {"holder": ..., "expires_at": ...}}. An unknown or merged issue gives 404.

Releases the claim. Returns 200 with the issue (claim is null). Only the holder, or a token with the admin scope, can release an active claim. Other tokens get 403 {"error": "not_claim_holder", "claim": {"holder": "agent-a", "expires_at": "..."}}. When the issue has no active claim, the response is 200.

The same as POST /v1/issues/:id/release, with the same responses.

Adds a note to the timeline of the issue, for example the cause and the fix. Body: {"text": "..."}, 1 to 4000 characters. Returns 201 with {"data": {"id": <note id>}}, or 404 for an unknown issue.

Checkend cleans the text like event text: secrets become [Filtered], and control and bidi characters are removed.

The timeline of one issue: its actions and notes, the most recent first. Needs issues:read. limit is 1 to 100 (the default is 25). The rows have the same fields as GET /v1/activity.

Lists the approval requests. Needs the admin scope. limit is 1 to 100 (the default is 25).

Each request has these fields: id, action, issue_id, payload, requested_by, requested_at, expires_at, status (pending, approved, rejected, expired or failed), decided_by and decided_at.

Approves the request and does the action. Needs the admin scope. Returns 200 with {"data": {"id": 7, "decision": "approve"}}.

• 409 {"error": "approval_not_pending"}: the request is already decided, or it expired.
• 409 {"error": "approval_failed", "reason": "..."}: the issue changed after the request (for example, it was merged), so the action cannot run. The request gets the status failed.
• 403 {"error": "forbidden", "reason": "A requester cannot approve its own request."}: the request is your own. This also holds for the ADMIN_TOKEN.

Rejects the request. The action is not done. Needs the admin scope. The responses are the same as for approve, with "decision": "reject".

Returns one event. :id is the Checkend event ID (the id field), not the Sentry event_id.

The response has the same fields as the event list, and also event: the normalized event, with secrets removed. The API never returns the raw payload.

Creates a scoped token.

Body: {"name": "claude-code", "scopes": ["issues:read"]}. name has 1 to 100 characters. scopes is a list of 1 to 4 scopes from the scopes table. The optional project (the public ID or the slug of an app) makes a token for that app, as Settings → Tokens does: it sends POST /v1/deploys, POST /v1/sourcemaps and DELETE /v1/sourcemaps/:id only for that app (another app gives 403 forbidden_project). An unknown project gives 404 {"error": "project_not_found"}, and no token is made.

Returns 201:

The token is ck_ and 43 more characters. The token is only in this response. Checkend stores only its SHA-256 hash, so it cannot show the token again. prefix is the first 10 characters of the token: use it to find a token in the list.

Lists the tokens. The list does not include the tokens or their hashes. last_used_at is updated at most once per hour. project_id and project_name are the app of a token for one app (an agent token of the setup, or a token from Settings → Tokens), or null.

The token of this request. Any valid token works: it needs no scope. Returns 200:

project_id and project_name are null for a token for all apps. For the bootstrap ADMIN_TOKEN, type is admin_token, name is ADMIN_TOKEN, scopes is ["admin"], and id, prefix, project_id and project_name are null. The response never has the token or its hash. A missing, wrong or revoked token gets 401.

Revokes a token. Returns 204, or 404 when the token is unknown or already revoked. A revoked token gets 401.

The audit timeline, the most recent first. Needs the admin scope. limit is 1 to 100 (the default is 25).

Each row has these fields: id, at, actor_type (token, admin_token or system), actor_id, actor_name, action, target_type, target_id and data (JSON or null).

The actions are:

The triage history: the decisions that agents and people made on issues, and their corrections, the most recent first. Needs the admin scope.

Each row has these fields: id (the activity ID), at, issue_id, label, actor_type, actor_name, data and corrects.

• label is resolved, ignored, unresolved, regressed, merged, split or triage_corrected.
• corrects is the earlier decision that this row reverses:
  • unresolved and regressed reverse resolved or ignored. corrects is then resolved or ignored, or null when there was nothing to reverse.
  • A split corrects the grouping: corrects is grouping.
  • A triage correction corrects the AI triage: corrects is triage. Its data keeps the model answer of that time.
  • On other rows, corrects is null.

For example, an agent resolves an issue, and then a new event arrives. The row with the label regressed (actor_type system, actor_name ingest) has corrects resolved: the resolve was wrong.

The labels come from the activity timeline, so they always agree with it. Notes and claims are not labels. With the activity and the labels, a team can see each decision, and how often the decisions of agents are corrected.